Thu, 02 Jul 2026 19:47 - Optimize Qwen enhancement stage

README.md

@@ -7,10 +7,10 @@ sdk_version: 5.49.1
 app_file: app.py
 pinned: false
 license: apache-2.0
-version: 1.0.0
+version: 1.0.1
 short_description: Powerful image editing - supports one or two input images.
 ---
 
-Pro Realism Edit Studio is a powerful image editor powered by [Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) with [Phr00t's Rapid-AIO v23](https://huggingface.co/Phr00t/Qwen-Image-Edit-Rapid-AIO) accelerated transformer for 4-step inference. Upload one or two input images, write a prompt, get high-quality results. Enhanced with Real-ESRGAN upscaling, GFPGAN face restoration, and multi-stage detail enhancement.
+Pro Realism Edit Studio is a powerful image editor powered by [Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) with [Phr00t's Rapid-AIO v23](https://huggingface.co/Phr00t/Qwen-Image-Edit-Rapid-AIO) accelerated transformer for 4-step inference. Upload one or two input images, write a prompt, get high-quality results. The enhancement stage uses Nomos-family tiled upscaling, Qwen-aware masked artifact repair, micro-detail sharpening, and final photographic grain.
 
 Video generation is disabled unless an owned Gradio video Space is configured with `VIDEO_SPACE_ID`.

app.py

@@ -5,12 +5,11 @@ Pro Realism Edit Studio - Enhanced Edition
 
 Advanced image editing and enhancement studio powered by:
 - Qwen-Image-Edit-2511 with Phr00t's Rapid-AIO v23 accelerated transformer
-- Real-ESRGAN for high-quality upscaling
-- GFPGAN/CodeFormer for face restoration
-- Multi-stage detail enhancement pipeline
+- Nomos-family tiled upscaling
+- Qwen-aware masked cleanup and final photographic detail
 
 Author: Enhanced with Hugging Face CLI and image generation expertise
-Version: 1.0.0
+Version: 1.0.1
 """
 
 import gradio as gr
@@ -43,7 +42,7 @@ from gradio_client import Client, handle_file
 
 # Base model configuration
 BASE_MODEL_ID = "Qwen/Qwen-Image-Edit-2511"
-APP_VERSION = "1.0.0"
+APP_VERSION = "1.0.1"
 PHR00T_REPO_ID = os.environ.get("PHR00T_REPO_ID", "Phr00t/Qwen-Image-Edit-Rapid-AIO").strip()
 RAPID_TRANSFORMER_FILENAME = os.environ.get(
     "RAPID_TRANSFORMER_FILENAME",
@@ -52,17 +51,15 @@ RAPID_TRANSFORMER_FILENAME = os.environ.get(
 PHR00T_TRANSFORMER_PREFIX = "model.diffusion_model."
 VIDEO_SPACE_ID = os.environ.get("VIDEO_SPACE_ID", "").strip()
 
-# Enhanced Upscaler Configuration
-UPSCALER_MODEL_ID = os.environ.get("UPSCALER_MODEL_ID", "ai-forever/Real-ESRGAN").strip()
-UPSCALER_MODEL_FILENAME = os.environ.get("UPSCALER_MODEL_FILENAME", "RealESRGAN_x4plus.pth").strip()
+# Qwen-optimized enhancement configuration
+UPSCALER_MODEL_ID = os.environ.get("UPSCALER_MODEL_ID", "Phips/4xNomos8k_atd_jpg").strip()
+UPSCALER_MODEL_FILENAME = os.environ.get("UPSCALER_MODEL_FILENAME", "4xNomos8k_atd_jpg.safetensors").strip()
 UPSCALER_TILE_SIZE = int(os.environ.get("UPSCALER_TILE_SIZE", "512"))
 UPSCALER_TILE_OVERLAP = int(os.environ.get("UPSCALER_TILE_OVERLAP", "64"))
 ENHANCE_MAX_INPUT_EDGE = int(os.environ.get("ENHANCE_MAX_INPUT_EDGE", "2048"))
-ENHANCE_GRAIN_STRENGTH = float(os.environ.get("ENHANCE_GRAIN_STRENGTH", "0.015"))
-
-# Face Restoration Configuration
-FACE_RESTORATION_MODEL = os.environ.get("FACE_RESTORATION_MODEL", "Xintao/GFPGAN").strip()
-FACE_RESTORATION_WEIGHTS = os.environ.get("FACE_RESTORATION_WEIGHTS", "GFPGANv1.3.pth").strip()
+ENHANCE_QWEN_DOWNSCALE_TRIGGER_EDGE = int(os.environ.get("ENHANCE_QWEN_DOWNSCALE_TRIGGER_EDGE", "1536"))
+ENHANCE_QWEN_DOWNSCALE_FACTOR = float(os.environ.get("ENHANCE_QWEN_DOWNSCALE_FACTOR", "0.75"))
+ENHANCE_GRAIN_STRENGTH = float(os.environ.get("ENHANCE_GRAIN_STRENGTH", "0.010"))
 
 # Advanced Detail Enhancement Configuration
 DETAIL_ENHANCEMENT_ENABLED = os.environ.get("DETAIL_ENHANCEMENT_ENABLED", "true").lower() == "true"
@@ -73,26 +70,16 @@ SMART_SHARPENING_STRENGTH = float(os.environ.get("SMART_SHARPENING_STRENGTH", "1
 # ============================================================================
 
 ENHANCE_MODE_OFF = "Off"
-ENHANCE_MODE_UPSCALE = "Upscale Only"
-ENHANCE_MODE_CLEAN = "Clean & Restore"
+ENHANCE_MODE_UPSCALE = "Upscale"
+ENHANCE_MODE_CLEAN = "Clean"
 ENHANCE_MODE_MAX_DETAIL = "Max Detail"
-ENHANCE_MODE_FACE_ENHANCE = "Face Enhance"
-ENHANCE_MODE_FULL_ENHANCE = "Full Enhance"
-ENHANCE_MODE_CHOICES = [
-    ENHANCE_MODE_OFF, 
-    ENHANCE_MODE_UPSCALE, 
-    ENHANCE_MODE_CLEAN, 
-    ENHANCE_MODE_MAX_DETAIL,
-    ENHANCE_MODE_FACE_ENHANCE,
-    ENHANCE_MODE_FULL_ENHANCE
-]
+ENHANCE_MODE_CHOICES = [ENHANCE_MODE_OFF, ENHANCE_MODE_UPSCALE, ENHANCE_MODE_CLEAN, ENHANCE_MODE_MAX_DETAIL]
 
 # ============================================================================
 # GLOBAL MODEL CACHE
 # ============================================================================
 
 _upscaler_model = None
-_face_restoration_model = None
 _detail_enhancement_model = None
 
 # ============================================================================
@@ -261,11 +248,11 @@ pipe.transformer.set_attn_processor(QwenDoubleStreamAttnProcessorFA3())
 print("Applied FA3 attention processor optimization")
 
 # ============================================================================
-# ENHANCED UPSCALER (Real-ESRGAN based)
+# QWEN-OPTIMIZED UPSCALER
 # ============================================================================
 
 def load_upscaler_model():
-    """Load Real-ESRGAN model for high-quality upscaling"""
+    """Load a Spandrel upscaler, defaulting to the Nomos model used by this Space."""
     global _upscaler_model
     if _upscaler_model is not None:
         return _upscaler_model
@@ -278,24 +265,29 @@ def load_upscaler_model():
         raise gr.Error("Enhance mode requires spandrel and spandrel_extra_arches to be installed. "
                        "Install with: pip install spandrel spandrel_extra_arches") from exc
 
-    try:
-        model_path = download_model_with_retry(UPSCALER_MODEL_ID, UPSCALER_MODEL_FILENAME)
-        model = spandrel.ModelLoader().load_from_file(model_path)
-        model.eval().to(device)
-        _upscaler_model = model
-        print(f"Successfully loaded upscaler: {UPSCALER_MODEL_ID}/{UPSCALER_MODEL_FILENAME}")
-        return _upscaler_model
-    except Exception as e:
-        print(f"Failed to load upscaler model: {e}")
-        print("Falling back to Nomos upscaler...")
+    candidates = [
+        (UPSCALER_MODEL_ID, UPSCALER_MODEL_FILENAME),
+        ("Phips/4xNomos8k_atd_jpg", "4xNomos8k_atd_jpg.safetensors"),
+    ]
+    seen = set()
+    errors = []
+    for repo_id, filename in candidates:
+        key = (repo_id, filename)
+        if key in seen:
+            continue
+        seen.add(key)
         try:
-            model_path = download_model_with_retry("Phips/4xNomos8k_atd_jpg", "4xNomos8k_atd_jpg.safetensors")
+            model_path = download_model_with_retry(repo_id, filename)
             model = spandrel.ModelLoader().load_from_file(model_path)
             model.eval().to(device)
             _upscaler_model = model
+            print(f"Successfully loaded upscaler: {repo_id}/{filename}")
             return _upscaler_model
-        except Exception as fallback_error:
-            raise gr.Error(f"Failed to load all upscaler models: {e} | {fallback_error}")
+        except Exception as exc:
+            errors.append(f"{repo_id}/{filename}: {exc}")
+            print(f"Failed to load upscaler {repo_id}/{filename}: {exc}")
+
+    raise gr.Error(f"Failed to load all upscaler models: {' | '.join(errors)}")
 
 def image_to_tensor(image):
     """Convert PIL Image to tensor"""
@@ -318,11 +310,24 @@ def validate_enhance_input_size(image):
             f"Consider resizing your image first."
         )
 
-def advanced_tile_upscale(image, scale=4):
-    """
-    Advanced tiling upscaler with improved blending and edge handling
-    Uses Real-ESRGAN for superior quality compared to Nomos
-    """
+def _tile_weight(height, width, overlap_y, overlap_x, touches_top, touches_bottom, touches_left, touches_right, dtype, device):
+    weight = torch.ones((1, 1, height, width), dtype=dtype, device=device)
+    if overlap_y > 1 and not touches_top:
+        ramp = torch.linspace(0.0, 1.0, overlap_y, dtype=dtype, device=device).view(1, 1, overlap_y, 1)
+        weight[:, :, :overlap_y, :] *= ramp
+    if overlap_y > 1 and not touches_bottom:
+        ramp = torch.linspace(1.0, 0.0, overlap_y, dtype=dtype, device=device).view(1, 1, overlap_y, 1)
+        weight[:, :, -overlap_y:, :] *= ramp
+    if overlap_x > 1 and not touches_left:
+        ramp = torch.linspace(0.0, 1.0, overlap_x, dtype=dtype, device=device).view(1, 1, 1, overlap_x)
+        weight[:, :, :, :overlap_x] *= ramp
+    if overlap_x > 1 and not touches_right:
+        ramp = torch.linspace(1.0, 0.0, overlap_x, dtype=dtype, device=device).view(1, 1, 1, overlap_x)
+        weight[:, :, :, -overlap_x:] *= ramp
+    return weight
+
+def tile_upscale(image, scale=4):
+    """Tiled Spandrel upscaling with feathered overlaps to avoid visible seams."""
     validate_enhance_input_size(image)
     model = load_upscaler_model()
     tensor = image_to_tensor(image)
@@ -355,7 +360,10 @@ def advanced_tile_upscale(image, scale=4):
                 x1 = min(x + tile_size, width)
                 tile = tensor[:, :, y:y1, x:x1]
                 
-                upscaled_tile = model(tile).clamp(0, 1)
+                upscaled_tile = model(tile)
+                if isinstance(upscaled_tile, (tuple, list)):
+                    upscaled_tile = upscaled_tile[0]
+                upscaled_tile = upscaled_tile.clamp(0, 1)
                 
                 scale_y = upscaled_tile.shape[-2] // tile.shape[-2]
                 scale_x = upscaled_tile.shape[-1] // tile.shape[-1]
@@ -370,12 +378,27 @@ def advanced_tile_upscale(image, scale=4):
                 
                 oy0, oy1 = y * scale_y, y1 * scale_y
                 ox0, ox1 = x * scale_x, x1 * scale_x
-                output[:, :, oy0:oy1, ox0:ox1] += upscaled_tile
-                weights[:, :, oy0:oy1, ox0:ox1] += 1
+                blend = _tile_weight(
+                    upscaled_tile.shape[-2],
+                    upscaled_tile.shape[-1],
+                    min(overlap * scale_y, max(1, upscaled_tile.shape[-2] // 2)),
+                    min(overlap * scale_x, max(1, upscaled_tile.shape[-1] // 2)),
+                    y == 0,
+                    y1 == height,
+                    x == 0,
+                    x1 == width,
+                    upscaled_tile.dtype,
+                    upscaled_tile.device,
+                )
+                output[:, :, oy0:oy1, ox0:ox1] += upscaled_tile * blend
+                weights[:, :, oy0:oy1, ox0:ox1] += blend
 
     output = output / weights.clamp_min(1)
     return tensor_to_image(output)
 
+def advanced_tile_upscale(image, scale=4):
+    return tile_upscale(image, scale=scale)
+
 # ============================================================================
 # ENHANCED DETAILER (Multi-stage processing)
 # ============================================================================
@@ -446,54 +469,9 @@ def apply_high_frequency_details(image, amount=0.6):
     return result
 
 # ============================================================================
-# ENHANCED CLEANER (Face Restoration + Artifact Removal)
+# LEGACY CLEANUP HELPERS
 # ============================================================================
 
-def load_face_restoration_model():
-    """Load GFPGAN model for face restoration"""
-    global _face_restoration_model
-    if _face_restoration_model is not None:
-        return _face_restoration_model
-    
-    try:
-        from gfpgan import GFPGANer
-        model_path = download_model_with_retry(FACE_RESTORATION_MODEL, FACE_RESTORATION_WEIGHTS)
-        
-        restorer = GFPGANer(
-            model_path=model_path,
-            upscale=1,
-            arch='clean',
-            channel_multiplier=2,
-            bg_upsampler=None
-        )
-        
-        _face_restoration_model = restorer
-        print("Successfully loaded GFPGAN face restoration model")
-        return _face_restoration_model
-        
-    except ImportError:
-        print("GFPGAN not available, face restoration will use fallback methods")
-        return None
-    except Exception as e:
-        print(f"Failed to load face restoration model: {e}")
-        return None
-
-def restore_faces(image):
-    """Restore faces in an image using GFPGAN"""
-    restorer = load_face_restoration_model()
-    if restorer is None:
-        print("Face restoration model not available, using skin repair fallback")
-        return repair_skin_texture(image)
-    
-    try:
-        img_array = np.array(image.convert("RGB"))
-        restored_array, _ = restorer.enhance(img_array, has_aligned=False, only_center_face=False, paste_back=True)
-        restored_image = Image.fromarray(restored_array.astype(np.uint8))
-        return restored_image
-    except Exception as e:
-        print(f"Face restoration failed: {e}, using skin repair fallback")
-        return repair_skin_texture(image)
-
 def remove_artifacts(image):
     """Remove compression artifacts and noise"""
     denoised = image.filter(ImageFilter.MedianFilter(size=3))
@@ -563,14 +541,96 @@ def add_film_grain(image, seed):
     array = np.clip(array + grain, 0, 255)
     return Image.fromarray(array.astype(np.uint8), mode="RGB")
 
+def _resize_to_even_dimensions(width, height):
+    return max(2, width - (width % 2)), max(2, height - (height % 2))
+
+def qwen_artifact_precondition(image):
+    """
+    Qwen edit outputs can show halftone/plastic texture at larger dimensions.
+    A small Lanczos downsample before the SR pass suppresses that pattern while
+    preserving prompt structure for the upscaler.
+    """
+    base = image.convert("RGB")
+    long_edge = max(base.size)
+    if long_edge <= ENHANCE_QWEN_DOWNSCALE_TRIGGER_EDGE:
+        return base
+
+    factor = min(0.95, max(0.50, ENHANCE_QWEN_DOWNSCALE_FACTOR))
+    new_width, new_height = _resize_to_even_dimensions(
+        int(round(base.width * factor)),
+        int(round(base.height * factor)),
+    )
+    if new_width >= base.width or new_height >= base.height:
+        return base
+    return base.resize((new_width, new_height), Image.Resampling.LANCZOS)
+
+def qwen_skin_mask(image):
+    base = image.convert("RGB")
+    ycbcr = np.asarray(base.convert("YCbCr"))
+    y = ycbcr[:, :, 0]
+    cb = ycbcr[:, :, 1]
+    cr = ycbcr[:, :, 2]
+    mask = (
+        (y > 45)
+        & (cb >= 72)
+        & (cb <= 145)
+        & (cr >= 128)
+        & (cr <= 182)
+    ).astype(np.uint8) * 255
+
+    try:
+        import cv2
+        kernel = np.ones((3, 3), np.uint8)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_OPEN, kernel)
+        mask = cv2.morphologyEx(mask, cv2.MORPH_CLOSE, kernel)
+        mask = cv2.GaussianBlur(mask, (0, 0), 1.6)
+    except ImportError:
+        mask_image = Image.fromarray(mask, mode="L")
+        mask_image = mask_image.filter(ImageFilter.MinFilter(size=3))
+        mask_image = mask_image.filter(ImageFilter.MaxFilter(size=5))
+        mask_image = mask_image.filter(ImageFilter.GaussianBlur(radius=1.4))
+        mask = np.asarray(mask_image)
+
+    return Image.fromarray(mask.astype(np.uint8), mode="L")
+
+def qwen_defect_mask(image):
+    base = image.convert("RGB")
+    skin = np.asarray(qwen_skin_mask(base)).astype(np.float32) / 255.0
+    gray = np.asarray(base.convert("L")).astype(np.float32)
+    local = np.asarray(base.convert("L").filter(ImageFilter.MedianFilter(size=5))).astype(np.float32)
+    pits = np.maximum(local - gray, 0.0)
+    smears = np.abs(gray - local)
+    mask = ((pits > 14.0) | (smears > 22.0)) & (skin > 0.12)
+    mask = (mask.astype(np.uint8) * 255)
+    mask_image = Image.fromarray(mask, mode="L")
+    mask_image = mask_image.filter(ImageFilter.MaxFilter(size=3))
+    return mask_image.filter(ImageFilter.GaussianBlur(radius=1.1))
+
+def masked_texture_repair(image, strength=0.55):
+    base = image.convert("RGB")
+    mask = qwen_defect_mask(base)
+    repaired = base.filter(ImageFilter.MedianFilter(size=3)).filter(ImageFilter.GaussianBlur(radius=0.22))
+    repaired = ImageEnhance.Sharpness(repaired).enhance(1.06)
+    mask = mask.point(lambda value: int(value * max(0.0, min(1.0, strength))))
+    return Image.composite(repaired, base, mask)
+
+def qwen_micro_detail(image, amount=0.35):
+    if amount <= 0:
+        return image.convert("RGB")
+    base = image.convert("RGB")
+    sharpened = base.filter(ImageFilter.UnsharpMask(radius=0.9, percent=int(95 * amount), threshold=3))
+    contrast = ImageEnhance.Contrast(sharpened).enhance(1.0 + amount * 0.05)
+    return Image.blend(base, contrast, alpha=min(0.65, amount))
+
+def add_photographic_grain(image, seed):
+    return add_film_grain(image, seed)
+
 # ============================================================================
 # ENHANCED APPLY ENHANCEMENT (Main enhancement pipeline)
 # ============================================================================
 
 def apply_enhancement(image, enhance_mode, seed=0, progress=None):
-    """
-    Apply various enhancement modes to the image
-    """
+    """Apply the Qwen 2511 / Rapid-AIO v23 post-process pipeline."""
     mode = enhance_mode or ENHANCE_MODE_OFF
     if mode not in ENHANCE_MODE_CHOICES:
         raise gr.Error(f"Unknown enhance mode: {mode}")
@@ -578,61 +638,43 @@ def apply_enhancement(image, enhance_mode, seed=0, progress=None):
         return image
 
     enhanced = image.convert("RGB")
-    
-    total_steps = 0
-    if mode == ENHANCE_MODE_UPSCALE:
-        total_steps = 1
-    elif mode == ENHANCE_MODE_CLEAN:
-        total_steps = 3
-    elif mode == ENHANCE_MODE_MAX_DETAIL:
-        total_steps = 4
-    elif mode == ENHANCE_MODE_FACE_ENHANCE:
-        total_steps = 2
-    elif mode == ENHANCE_MODE_FULL_ENHANCE:
-        total_steps = 5
-    
+    total_steps = {
+        ENHANCE_MODE_UPSCALE: 2,
+        ENHANCE_MODE_CLEAN: 3,
+        ENHANCE_MODE_MAX_DETAIL: 5,
+    }[mode]
     step = 0
-    
-    if mode == ENHANCE_MODE_FACE_ENHANCE:
-        if progress:
-            step += 1
-            progress(0.5 * step / total_steps, desc="Restoring faces...")
-        enhanced = restore_faces(enhanced)
-        if progress:
-            step += 1
-            progress(0.5 * step / total_steps, desc="Upscaling...")
-        enhanced = advanced_tile_upscale(enhanced)
-        return enhanced
-    
-    if mode in (ENHANCE_MODE_CLEAN, ENHANCE_MODE_FULL_ENHANCE):
-        if progress:
-            step += 1
-            progress(0.7 * step / total_steps, desc="Removing artifacts...")
-        enhanced = remove_artifacts(enhanced)
-        if progress:
-            step += 1
-            progress(0.7 * step / total_steps, desc="Repairing skin and faces...")
-        enhanced = enhanced_skin_repair(enhanced)
-        enhanced = restore_faces(enhanced)
-    
-    if mode in (ENHANCE_MODE_UPSCALE, ENHANCE_MODE_CLEAN, ENHANCE_MODE_MAX_DETAIL, ENHANCE_MODE_FULL_ENHANCE):
+
+    if progress:
+        step += 1
+        progress(0.85 * step / total_steps, desc="Preparing Qwen output...")
+    enhanced = qwen_artifact_precondition(enhanced)
+
+    if mode in (ENHANCE_MODE_CLEAN, ENHANCE_MODE_MAX_DETAIL):
         if progress:
             step += 1
-            progress(0.8 * step / total_steps, desc="Upscaling image...")
-        enhanced = advanced_tile_upscale(enhanced)
-    
-    if mode in (ENHANCE_MODE_MAX_DETAIL, ENHANCE_MODE_FULL_ENHANCE):
+            progress(0.85 * step / total_steps, desc="Repairing Qwen skin artifacts...")
+        enhanced = masked_texture_repair(enhanced, strength=0.55 if mode == ENHANCE_MODE_CLEAN else 0.68)
+        enhanced = qwen_micro_detail(enhanced, amount=0.18)
+
+    if mode == ENHANCE_MODE_MAX_DETAIL:
         if progress:
             step += 1
-            progress(0.9 * step / total_steps, desc="Enhancing details...")
-        enhanced = add_ultra_detail(enhanced, strength=0.7)
-        enhanced = apply_high_frequency_details(enhanced, amount=0.5)
-        enhanced = smart_sharpen(enhanced, strength=SMART_SHARPENING_STRENGTH)
+            progress(0.85 * step / total_steps, desc="Building micro detail...")
+        enhanced = qwen_micro_detail(enhanced, amount=0.36)
+
+    if progress:
+        step += 1
+        progress(0.85 * step / total_steps, desc="Upscaling with Nomos tiles...")
+    enhanced = tile_upscale(enhanced)
+
+    if mode == ENHANCE_MODE_MAX_DETAIL:
         if progress:
             step += 1
-            progress(0.95 * step / total_steps, desc="Adding final grain...")
-        enhanced = add_film_grain(enhanced, seed)
-    
+            progress(0.98, desc="Adding final photographic grain...")
+        enhanced = qwen_micro_detail(enhanced, amount=0.22)
+        enhanced = add_photographic_grain(enhanced, seed)
+
     return enhanced
 
 # ============================================================================
@@ -796,9 +838,10 @@ css = """
 with gr.Blocks(css=css) as demo:
     with gr.Column(elem_id="col-container"):
         gr.HTML(f"""
+        <!-- v{APP_VERSION} -->
         <div id="logo-title">
             <h1>Pro Realism Edit Studio - Enhanced</h1>
-            <h2>Rapid Edit with Real-ESRGAN & Face Restoration</h2>
+            <h2>Rapid Edit with Qwen-aware Nomos enhancement</h2>
         </div>
         """)
         
@@ -806,15 +849,13 @@ with gr.Blocks(css=css) as demo:
         Powered by:
         - [Qwen-Image-Edit-2511](https://huggingface.co/Qwen/Qwen-Image-Edit-2511) 
         - [Phr00t's Rapid-AIO v23](https://huggingface.co/Phr00t/Qwen-Image-Edit-Rapid-AIO) accelerated transformer
-        - [Real-ESRGAN](https://huggingface.co/ai-forever/Real-ESRGAN) for high-quality upscaling
-        - [GFPGAN](https://github.com/TencentARC/GFPGAN) for face restoration
+        - Nomos-family 4x tiled upscaling with masked Qwen artifact repair
         
         Upload an image and enter your prompt to edit it.
         
         Pro Tips:
-        - Use Face Enhance mode for portrait photography
-        - Use Max Detail for product shots and textures
-        - Use Full Enhance for comprehensive improvement
+        - Use Clean for portraits with smudged or pitted skin
+        - Use Max Detail for texture, grain, and sharper final output
         """)
         
         with gr.Row():
@@ -840,11 +881,9 @@ with gr.Blocks(css=css) as demo:
                 enhance_info = gr.Markdown("""
                 Enhancement Options:
                 - Off: No post-processing
-                - Upscale Only: 4x upscaling with Real-ESRGAN
-                - Clean & Restore: Artifact removal + skin/face restoration
-                - Max Detail: Full detail enhancement with sharpening
-                - Face Enhance: Specialized face restoration + upscaling
-                - Full Enhance: Complete pipeline (clean + detail + face + upscale)
+                - Upscale: Qwen precondition + 4x Nomos tiled upscale
+                - Clean: Masked Qwen artifact repair + upscaling
+                - Max Detail: Masked repair + micro detail + upscaling + final grain
                 """, visible=False)
                 
                 run_button = gr.Button("Generate!", variant="primary")

requirements.txt

@@ -16,22 +16,18 @@ Peft
 Torchao==0.11.0
 
 # Image processing and upscaling
-Spandrel
-Spandrel_extra_arches
+spandrel
+spandrel_extra_arches
 Pillow
 Numpy
 
-# Face restoration (optional but recommended)
-# Install with: pip install gfpgan
-# gfpgan>=1.0.0
-
-# OpenCV for face detection (optional)
-# Install with: pip install opencv-python
-# opencv-python>=4.5.0
-
-# SciPy for advanced image processing (fallback for face detection)
-# Install with: pip install scipy
-# scipy>=1.7.0
+# OpenCV for faster mask cleanup (optional)
+# Install with: pip install opencv-python
+# opencv-python>=4.5.0
+
+# SciPy for legacy image processing helpers (optional)
+# Install with: pip install scipy
+# scipy>=1.7.0
 
 # Gradio and utilities
 Gradio
@@ -45,6 +41,6 @@ Gradio_client
 # Performance monitoring (optional)
 # Install with: pip install psutil
 
-# Note: For full functionality, run:
-# pip install -r requirements_enhanced.txt
-# pip install gfpgan opencv-python scipy
+# Note: For optional CPU-side mask acceleration, run:
+# pip install -r requirements_enhanced.txt
+# pip install opencv-python scipy