first commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,14 @@
+__pycache__/
+*.py[cod]
+mod_tests/
+/.vs
+.vscode/
+.idea/
+venv/
+.venv/
+*.log
+.DS_Store
+.gradio
+download.py
+bk
+outputs/

README.md

@@ -0,0 +1,114 @@
+---
+title: Panorama Z-Image Turbo
+emoji: 🏞️
+colorFrom: red
+colorTo: orange
+sdk: gradio
+sdk_version: 5.50.0
+app_file: app.py
+pinned: true
+license: apache-2.0
+short_description: Create stunning panoramas with Z-Image-Turbo.
+---
+
+# Panorama Z-Image Turbo 🏞️✨
+
+[![Hugging Face Spaces](https://img.shields.io/badge/%F0%9F%A4%97%20Hugging%20Face-Spaces-blue)](https://huggingface.co/spaces/elismasilva/z-image-panorama) 
+
+Create stunning, seamless panoramic images by combining multiple distinct scenes with the power of the **Z-Image-Turbo** model. This application uses an advanced "Mixture of Diffusers" tiling pipeline to generate high-resolution compositions from left, center, and right text prompts, even on memory-constrained hardware, thanks to GGUF model support.
+
+![Example Panorama Image](https://huggingface.co/datasets/DEVAIEXP/assets/resolve/main/chineese%20young%20woman.png) 
+
+## What is Panorama Z-Image Turbo?
+
+Panorama Z-Image Turbo is a creative tool that leverages a sophisticated tiling mechanism to generate a single, wide-format image from three separate text prompts. Instead of stretching a single concept, you can describe different but related scenes for the left, center, and right portions of the image. The pipeline then intelligently generates each part and seamlessly blends them together.
+
+This is ideal for:
+*   **Creating expansive cityscapes or landscapes:** Describe a bustling street that transitions to a central plaza, which then leads to a quiet park.
+*   **Composing complex scenes:** Place different characters or objects side-by-side in a shared, coherent environment.
+*   **Generating ultra-wide art:** Create unique, high-resolution images perfect for wallpapers or digital art.
+*   **Multi-language creation:** With built-in translation, you can write prompts in English, Korean, or Chinese.
+
+The core technology uses a custom `ZImageMoDTilingPipeline` built on the Diffusers library. It has been meticulously adapted to the unique architecture of the `ZImageTransformer2DModel`, correctly handling its 16-channel latent space and specific input tensor format.
+
+### Key Features
+*   **Multi-Prompt Composition:** Control the left, center, and right of your image with unique prompts.
+*   **GGUF Transformer Support:** Utilizes a quantized GGUF version of the transformer, significantly reducing VRAM usage and making it possible to run on consumer GPUs.
+*   **Seamless Stitching:** Uses advanced blending methods (Cosine or Gaussian) to eliminate visible seams between tiles.
+*   **High-Resolution Output:** Generates images far wider than what a standard pipeline can handle in a single pass.
+*   **Efficient Memory Management:** Employs `diffusers`' standard CPU offloading to manage memory for non-transformer components.
+*   **Multi-Language Prompts:** Supports on-the-fly translation for prompts written in Korean and Chinese.
+
+---
+
+## Running the App Locally
+
+Follow these steps to run the Gradio application on your own machine.
+
+### 1. Prerequisites
+*   Python 3.10+
+*   Git and Git LFS installed.
+
+### 2. Clone the Repository
+```bash
+git clone https://huggingface.co/spaces/elismasilva/z-image-panorama
+cd z-image-panorama
+```
+
+### 3. Set Up a Virtual Environment (Recommended)
+```bash
+# Windows
+python -m venv venv
+.\venv\Scripts\activate
+
+# macOS / Linux
+python3 -m venv venv
+source venv/bin/activate
+```
+
+### 4. Install Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 5. Configure Local Model Paths (Optional)
+The app is configured to download models from the Hugging Face Hub by default. For faster startup and offline use, you can use local models by setting environment variables.
+
+For example, if you have the GGUF model in `F:\models\Z-Image-Turbo`:
+```bash
+# Windows CMD
+set GGUF_LOCAL_DIR=F:\models\Z-Image-Turbo
+
+# Windows PowerShell
+$env:GGUF_LOCAL_DIR="F:\models\Z-Image-Turbo"
+
+# Linux/macOS
+export GGUF_LOCAL_DIR=/path/to/your/models/Z-Image-Turbo
+```
+
+### 6. Run the Gradio App
+```bash
+python app.py
+```
+The application will start and provide a local URL (usually `http://127.0.0.1:7860`) that you can open in your web browser.
+
+---
+
+## Using the Command-Line Script (`infer.py`)
+
+The `infer.py` script allows you to test the pipeline directly from the command line.
+
+### 1. Configure the Script
+Open `infer.py` and modify the parameters inside the `main()` function, such as the `prompt_grid`, `target_height`, `target_width`, etc., to match your desired output.
+
+### 2. Run the Script
+Execute the script from your terminal:
+```bash
+python infer.py
+```
+The script will print its progress to the console, including the `tqdm` progress bar, and save the final image to the `outputs/` directory.
+
+## Acknowledgements
+*   **Alibaba Tongyi-MAI Team** for the powerful Z-Image Turbo model.
+*   The original authors of the **Mixture of Diffusers** technique.
+*   **Hugging Face** for the `diffusers` library and the Spaces platform.

app.py

@@ -0,0 +1,755 @@
+import spaces
+import gradio as gr
+import os
+import random
+import re
+import numpy as np
+import torch
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer
+
+# Import the custom tiling pipeline and its components
+from pipeline_z_image_mod import ZImageMoDTilingPipeline
+from diffusers import (
+    AutoencoderKL,
+    FlowMatchEulerDiscreteScheduler,
+    GGUFQuantizationConfig,
+)
+from diffusers.models import ZImageTransformer2DModel
+from huggingface_hub import hf_hub_download
+
+# Import the safety checker function
+try:
+    from prompt_check import is_unsafe_prompt
+
+    UNSAFE_CHECK_AVAILABLE = True
+except ImportError:
+    print("Warning: 'prompt_check.py' not found. NSFW prompt check will be disabled.")
+    UNSAFE_CHECK_AVAILABLE = False
+
+    def is_unsafe_prompt(*args, **kwargs):
+        return False
+
+
+# 1. Environment Variables for Model Paths
+# Base model for VAE, text_encoder, tokenizer
+BASE_MODEL_ID = os.getenv("BASE_MODEL_ID", "Tongyi-MAI/Z-Image-Turbo")
+# GGUF model for the transformer
+GGUF_REPO_ID = os.getenv("GGUF_REPO_ID", "jayn7/Z-Image-Turbo-GGUF")
+GGUF_FILENAME = os.getenv("GGUF_FILENAME", "z_image_turbo-Q4_K_M.gguf")
+GGUF_LOCAL_DIR = os.getenv(
+    "GGUF_LOCAL_DIR", None
+)  # Set this path for local use, e.g., "F:\\models\\Z-Image-Turbo"
+USE_SPACES_ENV = os.getenv("USE_SPACES", "false").lower()
+USE_SPACES = USE_SPACES_ENV not in ("false", "0", "no", "none")
+
+# System prompt for the safety checker
+UNSAFE_PROMPT_CHECK = os.getenv("UNSAFE_PROMPT_CHECK")
+MAX_SEED = np.iinfo(np.int32).max
+
+# 2. Load Models (GGUF + Standard Components)
+print("--- Loading Models ---")
+device = "cuda" if torch.cuda.is_available() else "cpu"
+
+print("Loading VAE...")
+if USE_SPACES:
+    vae = AutoencoderKL.from_pretrained(
+        BASE_MODEL_ID, subfolder="vae", torch_dtype=torch.bfloat16
+    ).to(device)
+else:
+    vae = AutoencoderKL.from_pretrained(
+        BASE_MODEL_ID, subfolder="vae", torch_dtype=torch.bfloat16
+    )
+
+print("Loading Text Encoder and Tokenizer...")
+if USE_SPACES:
+    text_encoder = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL_ID, subfolder="text_encoder", dtype=torch.bfloat16
+    ).to(device)
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID, subfolder="tokenizer")
+else:
+    text_encoder = AutoModelForCausalLM.from_pretrained(
+        BASE_MODEL_ID, subfolder="text_encoder", dtype=torch.bfloat16
+    )
+tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID, subfolder="tokenizer")
+
+print(f"Loading Transformer from GGUF: {GGUF_REPO_ID}/{GGUF_FILENAME}...")
+transformer_path = (
+    hf_hub_download(
+        GGUF_REPO_ID,
+        GGUF_FILENAME,
+        local_dir=GGUF_LOCAL_DIR,
+        local_dir_use_symlinks=False,
+    )
+    if GGUF_LOCAL_DIR
+    else hf_hub_download(GGUF_REPO_ID, GGUF_FILENAME)
+)
+
+if USE_SPACES:
+    transformer = ZImageTransformer2DModel.from_single_file(
+        transformer_path,
+        quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
+        dtype=torch.bfloat16,
+    ).to(device)
+else:
+    transformer = ZImageTransformer2DModel.from_single_file(
+        transformer_path,
+        quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16),
+        dtype=torch.bfloat16,
+    )
+
+
+# 3. Assemble the Tiling Pipeline
+print("\nAssembling the ZImageMoDTilingPipeline...")
+scheduler = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000, shift=3.0)
+if USE_SPACES:
+    pipe = ZImageMoDTilingPipeline(
+        vae=vae,
+        text_encoder=text_encoder,
+        tokenizer=tokenizer,  
+        scheduler=scheduler,      
+        transformer=transformer,
+    ).to(device)
+else:
+    pipe = ZImageMoDTilingPipeline(
+        vae=vae,
+        text_encoder=text_encoder,
+        tokenizer=tokenizer,        
+        scheduler=scheduler,
+        transformer=transformer,
+    )
+
+    print("Enabling model CPU offload...")
+    pipe.enable_model_cpu_offload()
+
+# Load Translation Models
+print("Loading translation models...")
+try:
+    ko_en_translator = pipeline("translation", model="Helsinki-NLP/opus-mt-ko-en")
+    zh_en_translator = pipeline("translation", model="Helsinki-NLP/opus-mt-zh-en")
+except Exception as e:
+    ko_en_translator, zh_en_translator = None, None
+    print(f"Warning: Could not load translation models: {e}")
+
+print("Pipeline loaded and ready.")
+
+
+# Helper Functions
+def translate_prompt(text: str, language: str) -> str:
+    """Translates text to English if the selected language is not English."""
+    if language == "English" or not text.strip():
+        return text
+    translated = text
+    if (
+        language == "Korean"
+        and ko_en_translator
+        and any("\uac00" <= char <= "\ud7a3" for char in text)
+    ):
+        translated = ko_en_translator(text)[0]["translation_text"]
+    elif (
+        language == "Chinese"
+        and zh_en_translator
+        and any("\u4e00" <= char <= "\u9fff" for char in text)
+    ):
+        translated = zh_en_translator(text)[0]["translation_text"]
+    return translated
+
+
+def create_hdr_effect(image, hdr_strength):
+    if hdr_strength == 0:
+        return image
+    from PIL import ImageEnhance, Image
+
+    if isinstance(image, Image.Image):
+        image = np.array(image)
+    from scipy.ndimage import gaussian_filter
+
+    blurred = gaussian_filter(image, sigma=5)
+    sharpened = np.clip(image + hdr_strength * (image - blurred), 0, 255).astype(
+        np.uint8
+    )
+    pil_img = Image.fromarray(sharpened)
+    converter = ImageEnhance.Color(pil_img)
+    return converter.enhance(1 + hdr_strength)
+
+
+@spaces.GPU(duration=120)
+def generate_z_image_panorama(
+    left_prompt,
+    center_prompt,
+    right_prompt,
+    left_gs,
+    center_gs,
+    right_gs,
+    overlap_pixels,
+    steps,
+    shift,
+    generation_seed,
+    tile_weighting_method,
+<<<<<<< HEAD
+    prompt_language,
+=======
+    prompt_language,  
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+    target_height,
+    target_width,
+    hdr,
+    randomize_seed,
+    progress=gr.Progress(track_tqdm=True),
+):
+    """
+    Generate a panoramic image using the Z-Image Turbo model with tiling and composition.
+    Args:
+        left_prompt (str): Text prompt for the left section of the panorama.
+        center_prompt (str): Text prompt for the center section of the panorama.
+        right_prompt (str): Text prompt for the right section of the panorama.
+        left_gs (float): Guidance scale for the left tile.
+        center_gs (float): Guidance scale for the center tile.
+        right_gs (float): Guidance scale for the right tile.
+        overlap_pixels (int): Number of pixels to overlap between tiles.
+        steps (int): Number of inference steps for generation.
+        shift (float): Time Shift.
+        generation_seed (int): Random seed for reproducibility.
+        tile_weighting_method (str): Method for weighting overlapping tile regions.
+        prompt_language (str): Language code for prompt translation.
+        target_height (int): Height of the generated panorama in pixels.
+        target_width (int): Width of the generated panorama in pixels.
+        hdr (float): HDR effect intensity.
+        randomize_seed (boolean): Not used.
+        progress (gr.Progress): Gradio progress tracker.
+    Returns:
+        PIL.Image: The generated panoramic image with optional HDR effect applied.
+    """
+    if not left_prompt or not center_prompt or not right_prompt:
+        gr.Info("⚡️ Prompts must be provided!")
+        return gr.skip()
+    # Safety Check    
+    prompts_to_check = [left_prompt, center_prompt, right_prompt]
+    for p in prompts_to_check:
+        if UNSAFE_CHECK_AVAILABLE and is_unsafe_prompt(
+            pipe.text_encoder,
+            device,
+            pipe.tokenizer,
+            system_prompt=UNSAFE_PROMPT_CHECK,
+            user_prompt=p,
+        ):
+            raise gr.Error(
+                f"Unsafe prompt detected. Please modify your prompt and try again."
+            )
+
+    generator = torch.Generator("cuda").manual_seed(generation_seed)
+    pipe.scheduler = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000, shift=shift)
+    
+    final_height, final_width = int(target_height), int(target_width)
+
+    translated_left = translate_prompt(left_prompt, prompt_language)
+    translated_center = translate_prompt(center_prompt, prompt_language)
+    translated_right = translate_prompt(right_prompt, prompt_language)
+
+    image = pipe(
+        prompt=[[translated_left, translated_center, translated_right]],
+        height=final_height,
+        width=final_width,
+        num_inference_steps=steps,
+        guidance_scale_tiles=[[left_gs, center_gs, right_gs]],
+        tile_overlap=overlap_pixels,
+        tile_weighting_method=tile_weighting_method,
+        generator=generator,
+    ).images[0]
+
+    return create_hdr_effect(image, hdr)
+
+
+def calculate_tile_size(target_height, target_width, overlap_pixels):
+    """
+    Calculate tile dimensions for panoramic image generation.
+
+    Args:
+        target_height (int): The target height of the final panoramic image in pixels.
+        target_width (int): The target width of the final panoramic image in pixels.
+        overlap_pixels (int): The number of overlapping pixels between adjacent tiles.
+
+    Returns:
+        tuple: A tuple of 2 gr.update objects containing:
+            - final_height: Final panorama height after tiling
+            - final_width: Final panorama width after tiling
+    """
+    num_cols = 3
+    num_rows = 1
+    tile_width = (target_width + (num_cols - 1) * overlap_pixels) // num_cols
+    tile_height = (target_height + (num_rows - 1) * overlap_pixels) // num_rows
+    tile_width -= tile_width % 16
+    tile_height -= tile_height % 16
+    final_width = tile_width * num_cols - (num_cols - 1) * overlap_pixels
+    final_height = tile_height * num_rows - (num_rows - 1) * overlap_pixels
+    return (
+        gr.update(value=final_height),
+        gr.update(value=final_width),
+    )
+
+
+def randomize_seed_fn(generation_seed: int, randomize_seed: bool) -> int:
+    if randomize_seed:
+        return random.randint(0, MAX_SEED)
+    return generation_seed
+
+
+def run_for_examples(
+    left_prompt,
+    center_prompt,
+    right_prompt,
+    left_gs,
+    center_gs,
+    right_gs,
+    overlap_pixels,
+    steps,
+    shift,
+    generation_seed,
+<<<<<<< HEAD
+    tile_weighting_method,
+=======
+    tile_weighting_method,  
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+    target_height,
+    target_width,
+    hdr,
+    randomize_seed
+):
+    return generate_z_image_panorama(
+        left_prompt,
+        center_prompt,
+        right_prompt,
+        left_gs,
+        center_gs,
+        right_gs,
+        overlap_pixels,
+        steps,
+        shift,
+        generation_seed,
+        tile_weighting_method,
+<<<<<<< HEAD
+        "English",
+=======
+        "English",       
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+        target_height,
+        target_width,
+        hdr,
+        randomize_seed
+    )
+
+
+def clear_result():
+    return gr.update(value=None)
+
+
+def update_dimensions_from_preset(resolution_preset):
+    """Updates the width and height sliders based on a preset string."""
+    match = re.search(r"(\d+)\s*[x]\s*(\d+)", resolution_preset)
+    if match:
+        width, height = int(match.group(1)), int(match.group(2))
+        return gr.update(value=width), gr.update(value=height)
+    return gr.update(), gr.update()
+
+
+# UI Layout
+theme = gr.themes.Default(
+    primary_hue="red", secondary_hue="orange", neutral_hue="gray"
+).set(
+    body_background_fill="*neutral_100",
+    body_background_fill_dark="*neutral_900",
+    body_text_color="*neutral_900",
+    body_text_color_dark="*neutral_100",
+    panel_background_fill="*neutral_800",
+    panel_background_fill_dark="*neutral_900",
+    input_background_fill="white",
+    input_background_fill_dark="*neutral_800",
+    button_primary_background_fill="*primary_500",
+    button_primary_background_fill_dark="*primary_700",
+    button_primary_text_color="white",
+    button_primary_text_color_dark="white",
+    button_secondary_background_fill="*secondary_500",
+    button_secondary_background_fill_dark="*secondary_700",
+    button_secondary_text_color="white",
+    button_secondary_text_color_dark="white",
+)
+
+css_code = ""
+
+try:
+    with open("./style.css", "r", encoding="utf-8") as f:
+        css_code += f.read() + "\n"
+except FileNotFoundError:
+    pass
+
+title = """<h1 align="center">Panorama Z-Image 🏞️✨</h1>
+           <div style="text-align: center;">
+                <span>Create panoramic compositions with Z-Image-Turbo.</span>
+           </div>
+           """
+# Adapted panoramic resolutions
+PANORAMIC_RESOLUTIONS = [
+    "2048x1024 (2:1)",
+    "2560x1024 (2.5:1)",
+    "3072x1024 (3:1)",
+    "2304x896 ( ~2.5:1)",
+    "2880x1152 (~2.5:1)",
+    "3840x1536 (2.5:1)",
+]
+
+with gr.Blocks(theme=theme, css=css_code, title="Panorama Z-Image") as app:
+    gr.Markdown(title)
+    with gr.Row():
+        with gr.Column(scale=7):
+            generate_button = gr.Button("Generate", variant="primary")
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Left Region")
+                    left_prompt = gr.Textbox(lines=4, label="Prompt (Left)")
+                    left_gs = gr.Slider(
+                        minimum=0.0,
+                        maximum=10.0,
+                        value=0.0,
+                        step=0.1,
+                        label="Left Guidance",
+<<<<<<< HEAD
+                        visible=False,
+=======
+                        visible=False
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("### Center Region")
+                    center_prompt = gr.Textbox(lines=4, label="Prompt (Center)")
+                    center_gs = gr.Slider(
+                        minimum=0.0,
+                        maximum=10.0,
+                        value=0.0,
+                        step=0.1,
+                        label="Center Guidance",
+<<<<<<< HEAD
+                        visible=False,
+=======
+                        visible=False
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    )
+                with gr.Column(scale=1):
+                    gr.Markdown("### Right Region")
+                    right_prompt = gr.Textbox(lines=4, label="Prompt (Right)")
+                    right_gs = gr.Slider(
+                        minimum=0.0,
+                        maximum=10.0,
+                        value=0.0,
+                        step=0.1,
+                        label="Right Guidance",
+<<<<<<< HEAD
+                        visible=False,
+=======
+                        visible=False
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    )
+            with gr.Row():
+                result = gr.Image(
+                    label="Generated Image",
+                    show_label=True,
+                    format="png",
+                    interactive=False,
+                )
+        with gr.Column(scale=1, min_width=200):
+            gr.Markdown(
+                """
+                ### Related Apps
+                Check out these other great demos:
+             
+                - **[Official Z-Image Demo](https://huggingface.co/spaces/Tongyi-MAI/Z-Image-Turbo)**
+                    *The official demo for single image generation.*
+                
+                - **[Panorama FLUX](https://huggingface.co/spaces/elismasilva/flux-1-panorama)**
+                    *The Panorama app using the FLUX model.*
+                """
+            )
+    with gr.Sidebar():
+        gr.Markdown("### Generation Parameters")
+        prompt_language = gr.Radio(
+            choices=["English", "Korean", "Chinese"],
+            value="English",
+            label="Prompt Language",
+        )
+
+        resolution_preset = gr.Dropdown(
+            choices=PANORAMIC_RESOLUTIONS,
+            value=PANORAMIC_RESOLUTIONS[2],
+            label="Panoramic Resolution Preset",
+        )
+
+        with gr.Row():
+            height = gr.Slider(
+                label="Target Height", value=1024, step=16, minimum=512, maximum=2048
+            )
+            width = gr.Slider(
+                label="Target Width", value=3072, step=16, minimum=512, maximum=4096
+            )
+        with gr.Row():
+            overlap = gr.Slider(
+                minimum=0, maximum=512, value=256, step=16, label="Tile Overlap"
+            )
+            tile_weighting_method = gr.Dropdown(
+                label="Blending Method", choices=["Cosine", "Gaussian"], value="Cosine"
+            )
+        with gr.Row():
+            calc_tile = gr.Button("Calculate Final Dimensions", variant="primary")
+        with gr.Row():
+            new_target_height = gr.Textbox(
+                label="Actual Height", value=1024, interactive=False
+            )
+            new_target_width = gr.Textbox(
+                label="Actual Width", value=3072, interactive=False
+            )
+        with gr.Row():
+            steps = gr.Slider(
+                minimum=1, maximum=50, value=9, step=1, label="Inference Steps"
+            )
+            shift = gr.Slider(label="Time Shift", minimum=1.0, maximum=10.0, value=3.0, step=0.1)
+        with gr.Row():
+            generation_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.Row():
+            hdr = gr.Slider(
+                minimum=0.0, maximum=1.0, value=0.1, step=0.00, label="HDR Effect"
+            )
+
+    with gr.Row():
+        gr.Examples(
+            examples=[                
+                [
+<<<<<<< HEAD
+                    "On the left side of a wide, wet stone courtyard at night, a traditional wooden temple building has a soft, warm glow from its illuminated windows, the environment is a deep, dark night sky.",
+                    "Young Chinese woman in red Hanfu, standing gracefully in the center of the stone-paved temple courtyard, intricate embroidery. Impeccable makeup, red floral forehead pattern. Elaborate high bun, golden phoenix headdress, red flowers, beads. Holds round folding fan with lady, trees, bird. Neon lightning-bolt lamp (⚡️), bright yellow glow, above extended left palm. Soft-lit outdoor night background, silhouetted tiered pagoda (西安大雁塔), blurred colorful distant lights.",
+                    "On the right side of the frame, a wooden temple corridor with a row of glowing paper lanterns recedes into the background. The lantern light reflects on the wet stone path below, and the distant pagoda is silhouetted against the same deep, dark night sky.",    
+=======
+                    "Iron Man, repulsor rays blasting enemies in destroyed cityscape, cinematic lighting, photorealistic. Focus: Iron Man.",
+                    "Captain America charging forward, vibranium shield deflecting energy blasts in destroyed cityscape, cinematic composition. Focus: Captain America.",
+                    "Thor wielding Stormbreaker in destroyed cityscape, lightning crackling, powerful strike downwards, cinematic photography. Focus: Thor.",
+                    0.0,
+                    0.0,
+                    0.0,
+                    200,
+                    8,
+                    619517442,
+                    "Cosine",                    
+                    1024,
+                    3440,
+                    0.0,
+                ],
+                [
+                    "A charming house in the countryside, by jakub rozalski, sunset lighting, elegant, highly detailed, sharp focus, artstation, stunning masterpiece",
+                    "A dirt road in the countryside crossing pastures, by jakub rozalski, sunset lighting, elegant, highly detailed, sharp focus, artstation, stunning masterpiece",
+                    "An old and rusty giant robot lying on a dirt road, by jakub rozalski, dark sunset lighting, elegant, highly detailed, sharp focus, artstation, stunning masterpiece",
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    0.0,
+                    0.0,
+                    0.0,
+                    256,
+<<<<<<< HEAD
+                    8,
+                    3.0,
+                    109320357,
+                    "Cosine",
+                    1024,
+                    3072,
+=======
+                    4,
+                    358867853,
+                    "Gaussian",                    
+                    1024,
+                    3808,
+                    0.0,
+                ],
+                [
+                    "A vibrant mountain slope in full spring bloom, covered in colorful wildflowers and lush green grass, a small stream meandering down, cinematic photo, bright morning light.",
+                    "The majestic, rocky peak of the same mountain under a clear summer sky, patches of green tundra, eagles soaring high above, strong midday sun. cinematic photo.",
+                    "The other side of the mountain descending into a valley ablaze with autumn colors, forests of red, orange, and yellow trees, a gentle haze in the air. cinematic photo, golden hour light.",
+                    0.0,
+                    0.0,
+                    0.0,
+                    280,
+                    4,
+                    20240521,
+                    "Cosine",                    
+                    1024,
+                    2896,
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    0.0,
+                    False,
+                ],
+                [
+<<<<<<< HEAD
+                    "Street photography of a bustling, modern Chinese city square in the morning. On the left, people in business attire walk past gleaming glass and steel office buildings under a hazy, bright sun.",
+                    "The center of the vast, modern plaza, where a large, elegant water fountain sprays water high into the air. In the background, through the mist of the fountain, the same modern glass and steel office buildings continue across the scene. The sun reflects off the wet plaza floor.",
+                    "The right side of the plaza, where groups of fashionable teenagers are casually standing near the concrete pillars of a modern building, looking at their smartphones under the same hazy, bright sun.",
+=======
+                    "Enchanted forest with glowing bioluminescent plants and mystical fog, fantasy art.",
+                    "Ancient elven castle with towering white spires bathed in moonlight, fantasy art.",
+                    "Majestic griffin soaring above a starry night sky, fantasy art.",
+                    0.0,
+                    0.0,
+                    0.0,
+                    224,
+                    6,
+                    1029384756,
+                    "Gaussian",                    
+                    1024,
+                    3392,
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    0.0,
+                    0.0,
+                    0.0,
+                    256,
+                    8,
+                    6.0,
+                    2024,
+                    "Cosine",
+                    1024,
+                    3072,
+                    0.0,
+                    False
+                ],
+                [
+                    "The edge of the green carpeted arena floor, with the blurred figures of spectators in the stands rising up in the background. A judge's table is partially visible on the far left.",
+                    "In the center of the green carpeted arena floor, a proud man in a fine suit stands with his perfectly groomed white poodle, both looking forward. The poodle wears a matching tiny tuxedo.",
+                    "Further down the green carpeted arena on the right, a line of other dog handlers and their breeds are waiting their turn in the distance, their forms slightly blurred by the depth of field.",
+                    0.0,
+                    0.0,
+                    0.0,
+                    200,
+<<<<<<< HEAD
+                    8,
+                    3.0,
+                    1146985307,
+                    "Gaussian",
+=======
+                    4,
+                    54321,
+                    "Gaussian",                    
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    1024,
+                    2672,
+                    0.0,
+                    False
+                ],
+                [
+<<<<<<< HEAD
+                    "Iron Man, repulsor rays blasting enemies in destroyed cityscape, cinematic lighting, photorealistic. Focus: Iron Man.",
+                    "Captain America charging forward, vibranium shield deflecting energy blasts in destroyed cityscape, cinematic composition. Focus: Captain America.",
+                    "Thor wielding Stormbreaker in destroyed cityscape, lightning crackling, powerful strike downwards, cinematic photography. Focus: Thor.",
+                    0,
+                    0,
+                    0,
+                    200,
+                    8,
+                    4.0,
+                    85512926,
+                    "Cosine",
+                    1024,
+                    3440,
+=======
+                    "A futuristic neon-lit city street at night, flying cars zooming past, towering holographic billboards. cyberpunk aesthetic, blade runner style.",
+                    "The entrance to a grimy, underground nightclub, a mysterious figure in a trench coat standing in the doorway, steam rising from a vent. cyberpunk aesthetic, blade runner style.",
+                    "A dark alleyway off the main street, piles of discarded electronics, graffiti glowing on the walls, rain glistening on the pavement. cyberpunk aesthetic, blade runner style.",
+                    0.0,
+                    0.0,
+                    0.0,
+                    300,
+                    8,
+                    98765,
+                    "Cosine",                    
+                    1024,
+                    3240,
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                    0.0,
+                    False
+                ]
+            ],
+            inputs=[
+                left_prompt,
+                center_prompt,
+                right_prompt,
+                left_gs,
+                center_gs,
+                right_gs,
+                overlap,
+                steps,
+                shift,
+                generation_seed,
+<<<<<<< HEAD
+                tile_weighting_method,
+=======
+                tile_weighting_method,               
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+                height,
+                width,
+                hdr,
+                randomize_seed
+            ],
+            fn=run_for_examples,
+            outputs=result,
+            cache_examples=False,
+            api_name=False,
+        )
+
+    # Event Handling
+    predict_inputs = [
+        left_prompt,
+        center_prompt,
+        right_prompt,
+        left_gs,
+        center_gs,
+        right_gs,
+        overlap,
+        steps,
+        shift,
+        generation_seed,
+        tile_weighting_method,
+<<<<<<< HEAD
+        prompt_language,
+=======
+        prompt_language,      
+>>>>>>> 9805178aafc167973e2c82d7be94d5a21a004362
+        new_target_height,
+        new_target_width,
+        hdr,
+    ]
+
+    resolution_preset.change(
+        fn=update_dimensions_from_preset,
+        inputs=resolution_preset,
+        outputs=[width, height],
+        api_name=False,
+    )
+    calc_tile.click(
+        fn=calculate_tile_size,
+        inputs=[height, width, overlap],
+        outputs=[new_target_height, new_target_width],
+        show_api=False,
+    )
+    generate_button.click(
+        fn=randomize_seed_fn,
+        inputs=[generation_seed, randomize_seed],
+        outputs=generation_seed,
+        queue=False,
+        api_name=False,
+    ).then(
+        fn=calculate_tile_size,
+        inputs=[height, width, overlap],
+        outputs=[new_target_height, new_target_width],
+        show_api=False,
+    ).then(
+        fn=generate_z_image_panorama,
+        inputs=predict_inputs,
+        outputs=result,
+        show_progress="full",
+        api_name="generate_z_image_panorama",
+    )
+
+app.queue().launch(mcp_server=True, share=True)

infer.py

@@ -0,0 +1,77 @@
+    
+import torch
+import time
+import os
+
+# 1. Import the final, self-contained tiling pipeline
+from pipeline_z_image_mod import ZImageMoDTilingPipeline 
+from diffusers import AutoencoderKL, FlowMatchEulerDiscreteScheduler, GGUFQuantizationConfig
+from diffusers.models import ZImageTransformer2DModel
+from transformers import AutoModelForCausalLM, AutoTokenizer
+from huggingface_hub import hf_hub_download
+
+def main():
+    # 1. Load Components Manually, using GGUF for the Transformer
+    print("--- 1. Loading Model Components (with GGUF) ---")
+    BASE_MODEL_ID = "Tongyi-MAI/Z-Image-Turbo"
+    GGUF_REPO_ID = "jayn7/Z-Image-Turbo-GGUF"
+    GGUF_FILENAME = "z_image_turbo-Q4_K_M.gguf"
+    GGUF_LOCAL_DIR = "F:\\models\\Z-Image-Turbo"
+    
+    print("Loading VAE...")
+    vae = AutoencoderKL.from_pretrained(BASE_MODEL_ID, subfolder="vae", torch_dtype=torch.bfloat16)
+    print("Loading Text Encoder and Tokenizer...")
+    text_encoder = AutoModelForCausalLM.from_pretrained(BASE_MODEL_ID, subfolder="text_encoder", torch_dtype=torch.bfloat16)
+    tokenizer = AutoTokenizer.from_pretrained(BASE_MODEL_ID, subfolder="tokenizer")
+    print(f"Loading Transformer from GGUF file: {GGUF_FILENAME}...")
+    transformer = ZImageTransformer2DModel.from_single_file(hf_hub_download(GGUF_REPO_ID, GGUF_FILENAME, local_dir=GGUF_LOCAL_DIR, local_dir_use_symlinks=False), quantization_config=GGUFQuantizationConfig(compute_dtype=torch.bfloat16), torch_dtype=torch.bfloat16)
+    
+    scheduler = FlowMatchEulerDiscreteScheduler(num_train_timesteps=1000, shift=3.0)
+
+    # 2. Initialize our Tiling Pipeline with Pre-loaded Components
+    print("\n--- 2. Assembling the ZImageMoDTilingPipeline ---")
+    pipe = ZImageMoDTilingPipeline(vae=vae, text_encoder=text_encoder, tokenizer=tokenizer, scheduler=scheduler, transformer=transformer)
+    
+    print("Enabling model CPU offload...")
+    pipe.enable_model_cpu_offload()
+
+    # 3. Set Up Tiling and Inference Parameters
+    print("\n--- 3. Setting Up Inference Parameters ---")
+    
+    prompt_grid = [[
+        "On the left side of a wide, wet stone courtyard at night, a traditional wooden temple building has a soft, warm glow from its illuminated windows, the environment is a deep, dark night sky.",
+        "Young Chinese woman in red Hanfu, standing gracefully in the center of the stone-paved temple courtyard, intricate embroidery. Impeccable makeup, red floral forehead pattern. Elaborate high bun, golden phoenix headdress, red flowers, beads. Holds round folding fan with lady, trees, bird. Neon lightning-bolt lamp (⚡️), bright yellow glow, above extended left palm. Soft-lit outdoor night background, silhouetted tiered pagoda (西安大雁塔), blurred colorful distant lights.",
+        "On the right side of the frame, a wooden temple corridor with a row of glowing paper lanterns recedes into the background. The lantern light reflects on the wet stone path below, and the distant pagoda is silhouetted against the same deep, dark night sky.",    
+    ]]
+    
+    target_height, canvas_width = 1024, 3072
+    num_inference_steps = 8
+    seed = 109320357
+    generator = torch.Generator("cuda").manual_seed(seed)
+    
+    # 4. Start Inference
+    print("\n--- 4. Starting Inference ---")
+    
+    start_inference_time = time.time()
+
+    # A single, clean call to our self-contained pipeline.
+    # No guidance_scale or negative_prompt is needed for the Turbo model.
+    image = pipe(
+        prompt=prompt_grid,
+        height=target_height,
+        width=canvas_width,
+        num_inference_steps=num_inference_steps,
+        generator=generator,
+    ).images[0]
+    
+    end_inference_time = time.time()
+    print(f"\nInference finished in {end_inference_time - start_inference_time:.2f} seconds.")
+
+    # 5. Save Output
+    if not os.path.exists("outputs"): os.makedirs("outputs")
+    output_filename = "outputs/z_image_panorama_final.png"
+    image.save(output_filename)
+    print(f"Image successfully saved as '{output_filename}'")
+
+if __name__ == "__main__":
+    main()

pipeline_z_image_mod.py

@@ -0,0 +1,214 @@
+# Copyright 2025, DEVAIEXP Team, Alibaba Z-Image Team and The HuggingFace Team. All rights reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+import gc
+import torch
+import numpy as np
+from enum import Enum
+from typing import List, Optional, Union
+
+from diffusers.utils import logging
+from diffusers.pipelines.z_image.pipeline_z_image import ZImagePipeline, calculate_shift
+from diffusers.pipelines.z_image.pipeline_output import ZImagePipelineOutput
+
+logger = logging.get_logger(__name__)
+
+# Tiling Engine Helper Functions
+def _adaptive_tile_size(image_size, base_tile_size=512, max_tile_size=1280):
+    width, height = image_size; aspect_ratio = width / height
+    if aspect_ratio > 1:
+        tile_width = min(width, max_tile_size); tile_height = min(int(tile_width / aspect_ratio), max_tile_size)
+    else:
+        tile_height = min(height, max_tile_size); tile_width = min(int(tile_height * aspect_ratio), max_tile_size)
+    return max(tile_width, base_tile_size), max(tile_height, base_tile_size)
+
+def _calculate_tile_positions(image_dim: int, tile_dim: int, overlap: int) -> List[int]:
+    if image_dim <= tile_dim: return [0]
+    positions = []; current_pos = 0; stride = tile_dim - overlap
+    while True:
+        positions.append(current_pos)
+        if current_pos + tile_dim >= image_dim: break
+        current_pos += stride
+        if current_pos > image_dim - tile_dim: break
+    if positions[-1] + tile_dim < image_dim: positions.append(image_dim - tile_dim)
+    return sorted(list(set(positions)))
+
+def _tile2pixel_indices(tile_row_pos, tile_col_pos, tile_width, tile_height, image_width, image_height):
+    px_row_init = tile_row_pos; px_col_init = tile_col_pos
+    px_row_end = min(px_row_init + tile_height, image_height)
+    px_col_end = min(px_col_init + tile_width, image_width)
+    return px_row_init, px_row_end, px_col_init, px_col_end
+
+def _tile2latent_indices(px_row_init, px_row_end, px_col_init, px_col_end, vae_scale_factor):
+    return px_row_init // vae_scale_factor, px_row_end // vae_scale_factor, px_col_init // vae_scale_factor, px_col_end // vae_scale_factor
+
+def release_memory(device):
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
+
+class ZImageMoDTilingPipeline(ZImagePipeline):
+    class TileWeightingMethod(Enum):
+        COSINE = "Cosine"; GAUSSIAN = "Gaussian"
+
+    def _generate_gaussian_weights(self, tile_width, tile_height, nbatches, device, dtype, sigma=0.4):
+        latent_width, latent_height = tile_width // self.vae_scale_factor, tile_height // self.vae_scale_factor
+        x, y = np.linspace(-1, 1, latent_width), np.linspace(-1, 1, latent_height)
+        xx, yy = np.meshgrid(x, y)
+        gaussian_weight_np = np.exp(-(xx**2 + yy**2) / (2 * sigma**2))
+        weights_torch_f32 = torch.tensor(gaussian_weight_np, device=device, dtype=torch.float32)
+        weights_torch_target_dtype = weights_torch_f32.to(dtype)
+        return torch.tile(weights_torch_target_dtype, (nbatches, self.transformer.in_channels, 1, 1))
+
+    def _generate_cosine_weights(self, tile_width, tile_height, nbatches, device, dtype):
+        latent_width, latent_height = tile_width // self.vae_scale_factor, tile_height // self.vae_scale_factor
+        x, y = np.arange(latent_width), np.arange(latent_height)
+        mid_x, mid_y = (latent_width - 1) / 2, (latent_height - 1) / 2
+        x_probs, y_probs = np.cos(np.pi * (x - mid_x) / latent_width), np.cos(np.pi * (y - mid_y) / latent_height)
+        weights_np = np.outer(y_probs, x_probs)
+        weights_torch = torch.tensor(weights_np, device=device, dtype=dtype)
+        return torch.tile(weights_torch, (nbatches, self.transformer.in_channels, 1, 1))
+
+    def prepare_tiles_weights(self, y_steps, x_steps, tile_height, tile_width, final_height, final_width, tile_weighting_method, tile_gaussian_sigma, batch_size, device, dtype):
+        tile_weights = np.empty((len(y_steps), len(x_steps)), dtype=object)
+        for row, y_start in enumerate(y_steps):
+            for col, x_start in enumerate(x_steps):
+                _, px_row_end, _, px_col_end = _tile2pixel_indices(y_start, x_start, tile_width, tile_height, final_width, final_height)
+                current_tile_h, current_tile_w = px_row_end - y_start, px_col_end - x_start
+                if tile_weighting_method == self.TileWeightingMethod.COSINE.value:
+                    tile_weights[row, col] = self._generate_cosine_weights(current_tile_w, current_tile_h, batch_size, device, dtype)
+                else:
+                    tile_weights[row, col] = self._generate_gaussian_weights(current_tile_w, current_tile_h, batch_size, device, dtype, sigma=tile_gaussian_sigma)
+        return tile_weights
+
+    @torch.no_grad()
+    def __call__(
+        self,
+        prompt: Union[str, List[List[str]]],
+        height: int = 1024,
+        width: int = 1024,
+        num_inference_steps: int = 9,
+        guidance_scale: float = 0.0,
+        generator: Optional[Union[torch.Generator, List[torch.Generator]]] = None,
+        max_tile_size: int = 1024,
+        tile_overlap: int = 256,
+        tile_weighting_method: str = "Cosine",
+        tile_gaussian_sigma: float = 0.4,
+        guidance_scale_tiles: Optional[List[List[float]]] = None,
+        max_sequence_length: int = 512,
+        output_type: Optional[str] = "pil",
+        return_dict: bool = True,        
+        **kwargs,
+    ):
+        # Handle negative_prompt from kwargs for backward compatibility if needed, but default to empty
+        negative_prompt = kwargs.get("negative_prompt", "")
+        
+        device = self._execution_device; batch_size = 1 
+        is_prompt_grid = isinstance(prompt, list) and all(isinstance(row, list) for row in prompt)
+        PIXEL_MULTIPLE = self.vae_scale_factor * 2 # 16
+
+        # Grid and Dimension Calculation
+        if is_prompt_grid:
+            grid_rows, grid_cols = len(prompt), len(prompt[0])
+            tile_width = (width + (grid_cols - 1) * tile_overlap) // grid_cols
+            tile_height = (height + (grid_rows - 1) * tile_overlap) // grid_rows
+            tile_width -= tile_width % PIXEL_MULTIPLE; tile_height -= tile_height % PIXEL_MULTIPLE
+            final_width = tile_width * grid_cols - (grid_cols - 1) * tile_overlap
+            final_height = tile_height * grid_rows - (grid_rows - 1) * tile_overlap
+            x_steps = [i * (tile_width - tile_overlap) for i in range(grid_cols)]
+            y_steps = [i * (tile_height - tile_overlap) for i in range(grid_rows)]
+        else: 
+            final_width, final_height = width, height
+            tile_width, tile_height = _adaptive_tile_size((final_width, final_height), max_tile_size=max_tile_size)
+            tile_width -= tile_width % PIXEL_MULTIPLE; tile_height -= tile_height % PIXEL_MULTIPLE
+            y_steps = _calculate_tile_positions(final_height, tile_height, tile_overlap)
+            x_steps = _calculate_tile_positions(final_width, tile_width, tile_overlap)
+            grid_rows, grid_cols = len(y_steps), len(x_steps)
+        
+        # Prompt Encoding
+        text_embeddings = []
+        for r in range(grid_rows):
+            row_embeddings = []
+            for c in range(grid_cols):
+                p = prompt[r][c] if is_prompt_grid else prompt                
+                prompt_embeds, _ = self.encode_prompt(
+                    prompt=p, do_classifier_free_guidance=False, device=device, max_sequence_length=max_sequence_length
+                )
+                row_embeddings.append({"prompt": prompt_embeds})
+            text_embeddings.append(row_embeddings)
+        
+        # Latent and Scheduler Setup
+        num_latent_channels = self.transformer.in_channels
+        latents = self.prepare_latents(
+            batch_size, num_latent_channels, final_height, final_width, torch.float32, device, generator
+        )
+        
+        image_seq_len = (tile_height // 2) * (tile_width // 2)
+        mu = calculate_shift(image_seq_len)
+        self.scheduler.set_timesteps(num_inference_steps, device=device, mu=mu)
+        timesteps = self.scheduler.timesteps
+        
+        # Prepare Weights and Offload
+        tile_weights = self.prepare_tiles_weights(y_steps, x_steps, tile_height, tile_width, final_height, final_width, tile_weighting_method, tile_gaussian_sigma, batch_size, device, latents.dtype)
+        self.text_encoder.to("cpu"); 
+        release_memory(device)
+
+        # Denoising Loop
+        with self.progress_bar(total=num_inference_steps) as progress_bar:
+            for t in timesteps:
+                denoised_step_canvas = torch.zeros_like(latents)
+                contributors = torch.zeros_like(latents)
+
+                for r, y_start in enumerate(y_steps):
+                    for c, x_start in enumerate(x_steps):
+                        px_r_init, px_r_end, px_c_init, px_c_end = _tile2pixel_indices(y_start, x_start, tile_width, tile_height, final_width, final_height)
+                        r_init, r_end, c_init, c_end = _tile2latent_indices(px_r_init, px_r_end, px_c_init, px_c_end, self.vae_scale_factor)
+                        
+                        tile_latents = latents[:, :, r_init:r_end, c_init:c_end]                        
+                        latents_typed = tile_latents.to(self.transformer.dtype)
+                        embeds = text_embeddings[r][c]                        
+                        timestep_model_input = t.expand(latents_typed.shape[0])
+                        timestep_norm = (1000 - timestep_model_input) / 1000
+                                                
+                        latent_model_input_list = list(latents_typed.unsqueeze(2).unbind(dim=0))
+                                                
+                        model_out_list = self.transformer(
+                            latent_model_input_list,
+                            timestep_norm,
+                            embeds["prompt"],
+                        )[0]
+
+                        
+                        noise_pred_tile = model_out_list[0].float()                        
+                        noise_pred_tile = -noise_pred_tile.squeeze(1)
+                        
+                        denoised_step_canvas[:, :, r_init:r_end, c_init:c_end] += noise_pred_tile * tile_weights[r, c]
+                        contributors[:, :, r_init:r_end, c_init:c_end] += tile_weights[r, c]
+                        
+                noise_pred_canvas = denoised_step_canvas / contributors
+                latents = self.scheduler.step(noise_pred_canvas.to(torch.float32), t, latents).prev_sample
+                progress_bar.update()
+
+        # Post-processing
+        if output_type == "latent":
+            image = latents
+        else:
+            self.vae.to(device)
+            latents = latents.to(self.vae.dtype)
+            latents = (latents / self.vae.config.scaling_factor) + self.vae.config.shift_factor
+            image = self.vae.decode(latents, return_dict=False)[0]
+            image = self.image_processor.postprocess(image, output_type=output_type)
+            
+        self.maybe_free_model_hooks(); 
+        return ZImagePipelineOutput(images=image) if return_dict else image

prompt_check.py

@@ -0,0 +1,30 @@
+import re
+
+import torch
+
+
+def clean_model_output(text):
+    text = re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL)
+    text = re.sub(r"\n*(assistant|user)\n*", "", text)
+    text = re.sub(r"\n+", "\n", text).strip()
+    return text
+
+
+def is_unsafe_prompt(model, device, tokenizer, system_prompt=None, user_prompt=None, max_new_token=10):
+    messages = [{"role": "system", "content": system_prompt}, {"role": "user", "content": user_prompt}]
+    with torch.inference_mode():
+        text = tokenizer.apply_chat_template(
+            messages,
+            tokenize=False,
+            add_generation_prompt=True,
+            enable_thinking=False,
+        )
+        model = model.to(device)
+        model_inputs = tokenizer([text], return_tensors="pt").to(device)
+
+        generated_ids = model.generate(**model_inputs, max_new_tokens=max_new_token)
+        output_ids = generated_ids[0][-max_new_token:].tolist()
+
+        content = tokenizer.decode(output_ids, skip_special_tokens=True).strip("\n")
+
+    return "yes" in content.lower()

requirements.txt

@@ -0,0 +1,17 @@
+gradio[mcp]==5.50.0
+spaces
+git+https://github.com/huggingface/diffusers.git@refs/pull/12756/head
+torch==2.8.0
+torchvision==0.23.0
+torchaudio==2.8.0
+transformers==4.56.0
+bitsandbytes==0.48.1
+xformers==0.0.32.post2
+hf_xet
+protobuf
+sacremoses
+sentencepiece
+ligo-segments
+scipy
+triton-windows<3.5; sys_platform == 'win32'
+triton==3.4.0; sys_platform != 'win32'

requirements_local.txt

@@ -0,0 +1,21 @@
+--extra-index-url https://download.pytorch.org/whl/cu126
+
+gradio[mcp]==5.50.0
+spaces
+gradio==5.50.0
+git+https://github.com/huggingface/diffusers.git@refs/pull/12756/head
+torch==2.8.0+cu126
+torchvision==0.23.0+cu126
+torchaudio==2.8.0+cu126
+transformers==4.56.0
+bitsandbytes==0.48.1
+xformers==0.0.32.post2
+hf_xet
+gguf
+protobuf
+sacremoses
+sentencepiece
+ligo-segments
+scipy
+triton-windows<3.5; sys_platform == 'win32'
+triton==3.4.0; sys_platform != 'win32'

style.css

@@ -0,0 +1,246 @@
+/* ==========================================================================
+   1. GLOBAL & LAYOUT STYLES
+   ========================================================================== */
+
+body {
+    font-family: 'Helvetica Neue', Helvetica, Arial, sans-serif;
+    margin: 0;
+    padding: 0;
+}
+
+/* Main application container styling */
+.gradio-container {
+    border-radius: 15px;
+    padding: 10px 20px; 
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.3); 
+    margin: 10px;
+}
+.column-container {
+    border-radius: 15px;
+    padding: 15px; 
+    box-shadow: 0 8px 30px rgba(0, 0, 0, 0.3); 
+    margin: auto;    
+}
+
+.action-console-col {
+    padding: 10px !important;
+    border-color: var(--border-color-primary) !important;
+    border-width: 1px !important;
+    border-radius: 8px;
+    margin-top: 10px;
+}
+.chatbot-container .message-row{
+    max-width: calc(100% - var(--spacing-sm) * 6) !important;
+}
+.chatbot-container pre code {
+    text-wrap: auto !important;
+}
+/* 2. Media Query for larger screens (desktops) */
+@media (min-width: 1281px) {
+    .gradio-container {        
+        padding: 10px 370px;
+        max-width: 2400px;
+    }
+}
+
+/* Text shadow for main headings for better readability */
+.gradio-container h1 {
+    text-shadow: 1px 1px 2px rgba(0, 0, 0, 0.2);
+}
+
+/* Utility class to make elements fill their container's width */
+/* .fillable {
+    width: 100% !important;
+    max-width: unset !important; 
+} */
+#trace-log {
+    height: 200px !important;
+    overflow-y: auto !important;
+    background-color: var(--background-fill-primary);
+    border: 1px solid var(--border-color-primary);
+    border-radius: 8px;
+    padding: 10px;
+}
+.fillable .sidebar-parent {
+    padding-left: 10px !important;
+    padding-right: 10px !important;
+}
+
+
+/* ==========================================================================
+   2. CUSTOM SCROLLBAR STYLES (GLOBAL & SIDEBAR)
+   ========================================================================== */
+
+/* --- For WebKit browsers (Chrome, Safari, Edge, etc.) --- */
+.sidebar-content::-webkit-scrollbar,
+body::-webkit-scrollbar {
+  width: 8px;
+  height: 8px;
+  background-color: transparent;
+}
+
+.sidebar-content::-webkit-scrollbar-track,
+body::-webkit-scrollbar-track {
+  background: transparent;
+  border-radius: 10px;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb,
+body::-webkit-scrollbar-thumb {
+  background-color: rgba(136, 136, 136, 0.4);
+  border-radius: 10px;
+  border: 2px solid transparent;
+  background-clip: content-box;
+}
+
+.sidebar-content::-webkit-scrollbar-thumb:hover,
+body::-webkit-scrollbar-thumb:hover {
+  background-color: rgba(136, 136, 136, 0.7);
+}
+
+/* --- For Firefox --- */
+.sidebar-content,
+html {
+  scrollbar-width: thin;
+  scrollbar-color: rgba(136, 136, 136, 0.7) transparent;
+}
+
+
+/* ==========================================================================
+   3. SIDEBAR STYLES
+   ========================================================================== */
+
+.sidebar {
+    border-radius: 10px;
+    padding: 10px;
+    box-shadow: 0 4px 15px rgba(0, 0, 0, 0.2);
+}
+
+/* Overrides for the content padding inside the sidebar */
+.sidebar .sidebar-content {
+    padding-left: 10px !important;
+    padding-right: 10px !important;
+}
+
+/* Centers text within Markdown blocks inside the sidebar */
+/* .sidebar .sidebar-content .column .block div .prose {
+    text-align: center;
+} */
+
+/* Stylish override for the sidebar toggle button */
+.sidebar .toggle-button {    
+    background: linear-gradient(135deg, var(--primary-500), var(--primary-600)) !important;
+    border: none;
+    padding: 12px 18px;
+    text-transform: uppercase;
+    font-weight: bold;
+    letter-spacing: 1px;
+    /* border-radius: 5px; */
+    position: absolute;
+    top: 50%;        
+    right: -28px !important;
+    left: auto !important;
+    transform: unset !important;   
+    border-radius: 0 var(--radius-lg) var(--radius-lg) 0 !important
+}
+
+.sidebar.right .toggle-button {
+    left: -28px !important;
+    right: auto !important; 
+    transform: rotate(180deg) !important;
+}
+
+.sidebar.open .chevron-left {
+    transform: rotate(-135deg);
+}
+
+.bottom-bar .toggle-bottom-button {
+    background: linear-gradient(135deg, var(--primary-500), var(--primary-600)) !important;
+}
+   
+.toggle-button:hover {
+    transform: scale(1.05);
+} 
+.bottom-bar .toggle-bottom-button .chevron {
+    width: 100%;
+    height: 100%;
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+}
+
+.bottom-bar .toggle-bottom-button .chevron-arrow {    
+    position: relative !important;
+    top: auto !important;
+    left: auto !important;        
+    width: 10px !important;
+    height: 10px !important;
+    border-bottom: 2px solid var(--body-text-color) !important;
+    border-right: 2px solid var(--body-text-color) !important;    
+    transform: rotate(-135deg) translateY(2px);
+    margin-bottom: -4px;
+}
+.bottom-bar.open .chevron-arrow {
+    transform: rotate(45deg) translateY(-2px) !important;
+}
+
+/* ==========================================================================
+   5. COMPONENT-SPECIFIC STYLES & OVERRIDES
+   ========================================================================== */
+
+/* Custom styling for the cancel button */
+#cancel-button { /* Corrected the typo from 'cancell' to 'cancel' */
+    background: linear-gradient(120deg, var(--neutral-500) 0%, var(--neutral-600) 60%, var(--neutral-700) 100%) !important;
+}
+.custom-dropdown .wrap-inner input {
+    padding-right: 22px;
+}
+
+#pagination-row {
+    display: flex !important;
+    justify-content: center !important;
+    align-items: center !important;
+    gap: 4px !important;
+    margin-top: 8px !important;
+    padding: 0 !important;
+    min-height: 0 !important;
+    background: transparent !important;
+    border: none !important;
+}
+
+.pagination-btn {
+    width: 28px !important;
+    height: 28px !important;
+    min-width: 28px !important;
+    padding: 0 !important;
+    display: flex !important;
+    align-items: center !important;
+    justify-content: center !important;
+    font-size: 12px !important;
+    line-height: 1 !important;
+    border-radius: 4px !important;
+    flex-grow: 0 !important;
+    box-shadow: none !important;
+}
+
+#page_label {
+    flex: 0 0 auto !important;
+    width: auto !important;
+    display: inline-block !important;
+    margin: 0 8px !important;
+    font-size: 11px !important;
+    font-family: monospace !important;
+    white-space: nowrap !important;
+    color: var(--body-text-color-subdued);
+}
+
+#page_label p {
+    margin: 0 !important;
+    padding: 0 !important;
+    display: inline !important;
+}
+#chat-examples  {
+    max-height: 300px;
+    overflow: auto !important;
+}