Upload 2 files

app.py

@@ -1,200 +1,183 @@
 import gradio as gr
-import tempfile
-import os
 import traceback
+import time
+import os
 from model import init, dehaze_inference, demoiring_inference, deblur_inference, get_model_status
 from PIL import Image
 from io import BytesIO
 
+# HF Spaces环境检测
+print("🚀 HuggingFace Spaces 环境检测:")
+print(f"CPU核心数: {os.cpu_count()}")
+
 
 def safe_init():
-    """安全初始化模型"""
+    """安全初始化"""
     try:
-        print("正在初始化模型...")
+        print("初始化模型...")
         init()
-        print("模型初始化完成！")
+        print("✅ 初始化成功")
         return True
     except Exception as e:
-        print(f"模型初始化失败: {e}")
-        print(f"详细错误: {traceback.format_exc()}")
+        print(f"❌ 初始化失败: {e}")
         return False
 
 
-# 初始化模型
+# 初始化
 model_loaded = safe_init()
 
 
-def preprocess_image(input_image):
-    """图像预处理：调整尺寸和格式"""
-    if input_image is None:
-        raise Exception("输入图像为空")
-
-    print(f"输入图像尺寸: {input_image.size}")
+def create_warning_image(message):
+    """创建警告图像"""
+    img = Image.new('RGB', (512, 256), color='#f0f0f0')
+    return img
 
-    # 图像预处理：确保图像尺寸合适
-    width, height = input_image.size
 
-    # 限制最小尺寸
-    min_size = 64
-    if width < min_size or height < min_size:
-        scale = max(min_size / width, min_size / height)
-        new_width = int(width * scale)
-        new_height = int(height * scale)
-        input_image = input_image.resize((new_width, new_height), Image.LANCZOS)
-        print(f"图像已放大至: {input_image.size}")
+def process_with_timeout(inference_func, image_bytes, timeout=30):
+    """带超时的处理函数"""
+    import signal
 
-    # 限制最大尺寸以避免内存问题
-    max_size = 2048
-    if width > max_size or height > max_size:
-        scale = min(max_size / width, max_size / height)
-        new_width = int(width * scale)
-        new_height = int(height * scale)
-        input_image = input_image.resize((new_width, new_height), Image.LANCZOS)
-        print(f"图像已缩小至: {input_image.size}")
+    def timeout_handler(signum, frame):
+        raise TimeoutError("处理超时")
 
-    # 确保图像尺寸是8的倍数
-    width, height = input_image.size
-    new_width = ((width + 7) // 8) * 8
-    new_height = ((height + 7) // 8) * 8
+    # 设置超时
+    signal.signal(signal.SIGALRM, timeout_handler)
+    signal.alarm(timeout)
 
-    if new_width != width or new_height != height:
-        input_image = input_image.resize((new_width, new_height), Image.LANCZOS)
-        print(f"图像已调整至8的倍数: {input_image.size}")
+    try:
+        result = inference_func(image_bytes)
+        signal.alarm(0)  # 取消超时
+        return result
+    except TimeoutError:
+        signal.alarm(0)
+        raise Exception(f"处理超时（>{timeout}秒）")
+    except Exception as e:
+        signal.alarm(0)
+        raise e
 
-    return input_image
 
+def process_image(input_image, task_type):
+    """统一处理函数"""
+    if input_image is None:
+        return create_warning_image("请上传图像")
 
-def create_error_image(error_message):
-    """创建错误提示图像"""
     try:
-        from PIL import ImageDraw, ImageFont
-        error_image = Image.new('RGB', (400, 200), color='lightgray')
-        draw = ImageDraw.Draw(error_image)
+        start_time = time.time()
+        print(f"开始处理: {task_type}")
 
-        # 尝试使用默认字体
-        try:
-            font = ImageFont.load_default()
-        except:
-            font = None
+        # 检查模型状态
+        status = get_model_status()
+        if not status.get(f"{task_type}_model_loaded", False):
+            return create_warning_image(f"{task_type}模型未加载")
 
-        # 添加错误信息
-        error_text = f"处理失败: {str(error_message)[:50]}"
-        draw.text((10, 90), error_text, fill='red', font=font)
+        # 图像预检查
+        if input_image.size[0] * input_image.size[1] > 1024 * 1024:
+            print("⚠️ 图像过大，将自动缩小")
 
-        return error_image
-    except:
-        # 如果创建错误图像也失败，返回简单的红色图像
-        return Image.new('RGB', (400, 200), color='red')
+        # 转换为字节流
+        buf = BytesIO()
+        input_image.save(buf, format='PNG')
+        image_bytes = buf.getvalue()
 
+        # 选择推理函数
+        inference_map = {
+            "dehaze": dehaze_inference,
+            "demoiring": demoiring_inference,
+            "deblur": deblur_inference
+        }
 
-def process_image(input_image, task_type):
-    """统一的图像处理函数"""
-    try:
-        print(f"开始处理图像，任务类型: {task_type}")
+        inference_func = inference_map[task_type]
 
-        # 检查模型状态
-        model_status = get_model_status()
-        if task_type == "dehaze" and not model_status["dehaze_model_loaded"]:
-            raise Exception("去雾模型未加载")
-        elif task_type == "demoiring" and not model_status["demoiring_model_loaded"]:
-            raise Exception("去摩尔纹模型未加载")
-        elif task_type == "deblur" and not model_status["deblur_model_loaded"]:
-            raise Exception("运动去模糊模型未加载")
-
-        # 预处理图像
-        processed_image = preprocess_image(input_image)
-
-        # 创建临时文件保存输入图像
-        with tempfile.NamedTemporaryFile(suffix=".png", delete=False) as temp_input:
-            processed_image.save(temp_input.name, format="PNG")
-            temp_input_path = temp_input.name
-
-        # 读取输入图像并进行推理
-        with open(temp_input_path, "rb") as f:
-            input_bytes = f.read()
-            print(f"读取到 {len(input_bytes)} 字节的图像数据")
-
-        print("开始推理...")
-
-        # 根据任务类型选择推理函数
-        if task_type == "dehaze":
-            result_bytes = dehaze_inference(input_bytes)
-        elif task_type == "demoiring":
-            result_bytes = demoiring_inference(input_bytes)
-        elif task_type == "deblur":
-            result_bytes = deblur_inference(input_bytes)
-        else:
-            raise Exception(f"不支持的任务类型: {task_type}")
-
-        print(f"推理完成，输出 {len(result_bytes)} 字节")
-
-        # 清理临时文件
-        os.unlink(temp_input_path)
-
-        # 将字节流转换为PIL图像对象
+        # 执行推理（带超时保护）
+        try:
+            result_bytes = process_with_timeout(inference_func, image_bytes, timeout=25)
+        except Exception as e:
+            if "超时" in str(e):
+                print("⚠️ 处理超时，尝试降低图像质量...")
+                # 缩小图像重试
+                small_image = input_image.resize(
+                    (input_image.size[0] // 2, input_image.size[1] // 2),
+                    Image.LANCZOS
+                )
+                buf = BytesIO()
+                small_image.save(buf, format='PNG')
+                image_bytes = buf.getvalue()
+                result_bytes = process_with_timeout(inference_func, image_bytes, timeout=20)
+            else:
+                raise e
+
+        # 转换结果
         result_image = Image.open(BytesIO(result_bytes))
-        print(f"输出图像尺寸: {result_image.size}")
+
+        elapsed = time.time() - start_time
+        print(f"✅ 处理完成: {elapsed:.2f}秒")
 
         return result_image
 
     except Exception as e:
-        error_msg = f"处理图像时出错: {e}"
-        print(error_msg)
-        print(f"详细错误: {traceback.format_exc()}")
-        return create_error_image(error_msg)
+        error_msg = f"处理失败: {str(e)}"
+        print(f"❌ {error_msg}")
+        return create_warning_image(error_msg)
 
 
-def dehaze_image(input_image):
-    """去雾处理函数"""
-    return process_image(input_image, "dehaze")
+# 创建处理函数
+def dehaze_process(image):
+    return process_image(image, "dehaze")
 
 
-def demoiring_image(input_image):
-    """去摩尔纹处理函数"""
-    return process_image(input_image, "demoiring")
+def demoiring_process(image):
+    return process_image(image, "demoiring")
 
 
-def deblur_image(input_image):
-    """运动去模糊处理函数"""
-    return process_image(input_image, "deblur")
+def deblur_process(image):
+    return process_image(image, "deblur")
 
 
-def get_model_info():
-    """获取模型状态信息"""
+def get_system_info():
+    """获取系统信息"""
     status = get_model_status()
-    info = "模型加载状态:\n"
-    info += f"🌫️ 去雾模型: {'✅ 已加载' if status['dehaze_model_loaded'] else '❌ 未加载'}\n"
-    info += f"🔍 去摩尔纹模型: {'✅ 已加载' if status['demoiring_model_loaded'] else '❌ 未加载'}\n"
-    info += f"🏃 运动去模糊模型: {'✅ 已加载' if status['deblur_model_loaded'] else '❌ 未加载'}"
+    info = "🖥️ HuggingFace Spaces (免费版)\n"
+    info += f"💾 内存: 有限\n"
+    info += f"⚡ CPU: {os.cpu_count()}核\n\n"
+    info += "📊 模型状态:\n"
+    info += f"🌫️ 去雾: {'✅' if status['dehaze_model_loaded'] else '❌'}\n"
+    info += f"🔍 去摩尔纹: {'✅' if status['demoiring_model_loaded'] else '❌'}\n"
+    info += f"🏃 去模糊: {'✅' if status['deblur_model_loaded'] else '❌'}\n\n"
+    info += "⚠️ 注意: 大图像会自动缩小以适应免费版限制"
     return info
 
 
-# 创建 Gradio 界面
+# 创建界面
 def create_interface():
-    with gr.Blocks(title="FPro 图像处理工具") as demo:
-        gr.Markdown("# FPro 图像处理工具")
-        gr.Markdown("基于 FPro (Frequency Prompted Transformer) 模型的图像处理工具，支持去雾、去摩尔纹和运动去模糊功能。")
-
-        # 模型状态信息
+    # 使用简单主题以减少资源占用
+    with gr.Blocks(
+            title="FPro图像处理 - HF Spaces版",
+            theme=gr.themes.Default(),
+            css=".gradio-container {max-width: 100% !important}"
+    ) as demo:
+        gr.Markdown("# 🚀 FPro 图像处理工具")
+        gr.Markdown("**HuggingFace Spaces 免费版 - 极速优化**")
+
+        # 系统信息
         with gr.Row():
-            model_info = gr.Textbox(
-                label="模型状态",
-                value=get_model_info(),
+            system_info = gr.Textbox(
+                label="系统信息",
+                value=get_system_info(),
                 interactive=False,
-                lines=4
+                lines=6,
+                max_lines=6
             )
 
-        # 创建标签页
+        # 主要功能区
         with gr.Tabs():
-            # 去雾标签页
-            with gr.TabItem("🌫️ 图像去雾"):
-                gr.Markdown("### 上传有雾图像，模型将自动去除雾气")
+            # 去雾
+            with gr.TabItem("🌫️ 去雾"):
                 with gr.Row():
                     with gr.Column():
                         dehaze_input = gr.Image(
                             type="pil",
                             label="上传有雾图像",
-                            height=400
+                            height=300
                         )
                         dehaze_btn = gr.Button("开始去雾", variant="primary")
 
@@ -202,24 +185,19 @@ def create_interface():
                         dehaze_output = gr.Image(
                             type="pil",
                             label="去雾结果",
-                            height=400
+                            height=300
                         )
 
-                dehaze_btn.click(
-                    fn=dehaze_image,
-                    inputs=[dehaze_input],
-                    outputs=[dehaze_output]
-                )
+                dehaze_btn.click(dehaze_process, dehaze_input, dehaze_output)
 
-            # 去摩尔纹标签页
+            # 去摩尔纹
             with gr.TabItem("🔍 去摩尔纹"):
-                gr.Markdown("### 上传有摩尔纹的图像，模型将去除摩尔纹效应")
                 with gr.Row():
                     with gr.Column():
                         demoiring_input = gr.Image(
                             type="pil",
-                            label="上传有摩尔纹图像",
-                            height=400
+                            label="上传摩尔纹图像",
+                            height=300
                         )
                         demoiring_btn = gr.Button("开始去摩尔纹", variant="primary")
 
@@ -227,24 +205,19 @@ def create_interface():
                         demoiring_output = gr.Image(
                             type="pil",
                             label="去摩尔纹结果",
-                            height=400
+                            height=300
                         )
 
-                demoiring_btn.click(
-                    fn=demoiring_image,
-                    inputs=[demoiring_input],
-                    outputs=[demoiring_output]
-                )
+                demoiring_btn.click(demoiring_process, demoiring_input, demoiring_output)
 
-            # 运动去模糊标签页
-            with gr.TabItem("🏃 运动去模糊"):
-                gr.Markdown("### 上传运动模糊的图像，模型将去除运动模糊效应")
+            # 去模糊
+            with gr.TabItem("🏃 去模糊"):
                 with gr.Row():
                     with gr.Column():
                         deblur_input = gr.Image(
                             type="pil",
-                            label="上传运动模糊图像",
-                            height=400
+                            label="上传模糊图像",
+                            height=300
                         )
                         deblur_btn = gr.Button("开始去模糊", variant="primary")
 
@@ -252,54 +225,43 @@ def create_interface():
                         deblur_output = gr.Image(
                             type="pil",
                             label="去模糊结果",
-                            height=400
+                            height=300
                         )
 
-                deblur_btn.click(
-                    fn=deblur_image,
-                    inputs=[deblur_input],
-                    outputs=[deblur_output]
-                )
+                deblur_btn.click(deblur_process, deblur_input, deblur_output)
 
-        # 使用说明
+        # 使用说明 - 简化版
         with gr.Accordion("使用说明", open=False):
             gr.Markdown("""
-            ### 📋 使用指南
-
-            **去雾功能:**
-            - 适用于雾霾、雾气等造成的图像模糊
-            - 支持各种室外场景的去雾处理
-            - 建议上传清晰度较高的原始图像
-
-            **去摩尔纹功能:**
-            - 适用于屏幕拍摄、扫描等产生的摩尔纹
-            - 可以处理各种周期性干扰模式
-            - 特别适合处理数字屏幕拍摄的图像
-
-            **运动去模糊功能:**
-            - 适用于拍摄时相机抖动或物体运动造成的模糊
-            - 可以恢复运动模糊图像的清晰度
-            - 适合处理快速运动场景的模糊图像
-
-            **注意事项:**
-            - 支持 PNG、JPG 等常见图像格式
-            - 图像会自动调整尺寸以适应模型要求
-            - 处理时间根据图像大小和复杂度而定
-            - 建议图像尺寸不超过 2048x2048 像素
+            ### ⚡ HF Spaces 优化说明
+
+            **🎯 自动优化特性:**
+            - 图像自动缩放至512px以内
+            - 智能切块减少内存使用
+            - 超时保护防止崩溃
+            - 内存自动清理
+
+            **⚠️ 免费版限制:**
+            - 处理时间: 约20-30秒
+            - 图像尺寸: 自动缩放
+            - 并发处理: 不支持
+
+            **💡 使用建议:**
+            - 上传清晰的原图
+            - 耐心等待处理完成
+            - 大图会自动缩小
             """)
 
-        # 底部信息
         gr.Markdown("""
         ---
-        **技术支持:** 基于 FPro (Frequency Prompted Transformer) 架构  
-        **部署平台:** Hugging Face Spaces  
-        **开发者:** yssszzzzzzzzy
+        **基于 FPro (Frequency Prompted Transformer) | HuggingFace Spaces 优化版**
         """)
 
     return demo
 
 
 if __name__ == "__main__":
-    print("启动 Gradio 应用...")
+    print("🌐 启动 HuggingFace Spaces 应用...")
     demo = create_interface()
+    demo.queue(concurrency_count=1, max_size=3)  # 限制并发
     demo.launch()

model.py

@@ -1,262 +1,307 @@
-# model.py - 整合版本：支持去雾、去摩尔纹和运动去模糊
+# model.py - HuggingFace Spaces极限优化版
 import yaml, torch, math, numpy as np
 import torch.nn.functional as F
 from PIL import Image
 from io import BytesIO
 from basicsr.models.archs.FPro_arch import FPro
+import gc
 
-# 强制使用 CPU
+# HF Spaces环境优化设置
+torch.set_num_threads(2)  # HF Spaces通常是2核CPU
+torch.set_num_interop_threads(1)
 device = torch.device('cpu')
 
-# 全局变量存储三个模型
+# 全局模型变量
 dehaze_model = None
 demoiring_model = None
 deblur_model = None
 
+# 极限优化配置
+EXTREME_OPTIMIZATION = {
+    'max_image_size': 512,  # 严格限制最大图像尺寸
+    'min_tile_size': 128,  # 最小切块尺寸
+    'max_tiles': 4,  # 最大切块数量 (2x2)
+    'overlap_ratio': 0.1,  # 最小重叠比例
+    'memory_limit_mb': 1024,  # 内存限制
+    'enable_half_precision': False,  # HF Spaces上通常不支持
+}
 
-def splitimage(imgtensor, crop_size=256, overlap_size=158):
-    """切块函数，与原代码保持一致"""
+
+def aggressive_image_resize(image, max_size=512):
+    """激进的图像缩放策略"""
+    w, h = image.size
+
+    # 如果图像太大，强制缩小
+    if max(w, h) > max_size:
+        scale = max_size / max(w, h)
+        new_w, new_h = int(w * scale), int(h * scale)
+
+        # 确保是8的倍数，但优先保证小尺寸
+        new_w = ((new_w + 7) // 8) * 8
+        new_h = ((new_h + 7) // 8) * 8
+
+        # 如果调整后还是太大，再次缩小
+        if max(new_w, new_h) > max_size:
+            new_w = min(new_w, max_size)
+            new_h = min(new_h, max_size)
+            new_w = (new_w // 8) * 8
+            new_h = (new_h // 8) * 8
+
+        image = image.resize((new_w, new_h), Image.LANCZOS)
+        print(f"图像已缩放: {w}x{h} -> {new_w}x{new_h}")
+
+    return image
+
+
+def minimal_splitimage(imgtensor, max_tiles=4):
+    """最小化切块策略"""
     _, C, H, W = imgtensor.shape
-    hstarts = [x for x in range(0, H, crop_size - overlap_size)]
-    while hstarts and hstarts[-1] + crop_size >= H:
-        hstarts.pop()
-    hstarts.append(H - crop_size)
-    wstarts = [x for x in range(0, W, crop_size - overlap_size)]
-    while wstarts and wstarts[-1] + crop_size >= W:
-        wstarts.pop()
-    wstarts.append(W - crop_size)
-    starts = []
+
+    # 如果图像小于256x256，直接返回
+    if H <= 256 and W <= 256:
+        return [imgtensor], [(0, 0)]
+
+    # 计算最优切块配置以限制切块数量
+    if max_tiles == 1:
+        return [imgtensor], [(0, 0)]
+    elif max_tiles == 4:  # 2x2
+        crop_h = H // 2 if H > 256 else H
+        crop_w = W // 2 if W > 256 else W
+        overlap = min(32, crop_h // 8, crop_w // 8)
+    else:
+        # 默认单切块
+        return [imgtensor], [(0, 0)]
+
+    # 简化的2x2切块
     split_data = []
-    for hs in hstarts:
-        for ws in wstarts:
-            cimgdata = imgtensor[:, :, hs:hs + crop_size, ws:ws + crop_size]
-            starts.append((hs, ws))
-            split_data.append(cimgdata)
-    return split_data, starts
+    starts = []
 
+    h_mid = H // 2
+    w_mid = W // 2
 
-def get_scoremap(H, W, C, B=1, is_mean=True):
-    """权重图生成函数，与原代码保持一致"""
-    center_h = H / 2
-    center_w = W / 2
+    # 四个切块的位置
+    positions = [
+        (0, 0, min(crop_h + overlap, H), min(crop_w + overlap, W)),
+        (0, max(0, w_mid - overlap), min(crop_h + overlap, H), W),
+        (max(0, h_mid - overlap), 0, H, min(crop_w + overlap, W)),
+        (max(0, h_mid - overlap), max(0, w_mid - overlap), H, W)
+    ]
 
-    score = torch.ones((B, C, H, W))
-    if not is_mean:
-        for h in range(H):
-            for w in range(W):
-                score[:, :, h, w] = 1.0 / (math.sqrt((h - center_h) ** 2 + (w - center_w) ** 2 + 1e-6))
-    return score
+    for h_start, w_start, h_end, w_end in positions:
+        if h_end <= h_start or w_end <= w_start:
+            continue
 
+        patch = imgtensor[:, :, h_start:h_end, w_start:w_end]
+        split_data.append(patch)
+        starts.append((h_start, w_start))
 
-def mergeimage(split_data, starts, crop_size=256, resolution=(1, 3, 128, 128)):
-    """图像合并函数，与原代码保持一致"""
-    B, C, H, W = resolution[0], resolution[1], resolution[2], resolution[3]
-    tot_score = torch.zeros((B, C, H, W))
-    merge_img = torch.zeros((B, C, H, W))
-    scoremap = get_scoremap(crop_size, crop_size, C, B=B, is_mean=True)
+    print(f"图像分割为 {len(split_data)} 个切块")
+    return split_data, starts
 
-    for simg, cstart in zip(split_data, starts):
-        hs, ws = cstart
-        merge_img[:, :, hs:hs + crop_size, ws:ws + crop_size] += scoremap * simg
-        tot_score[:, :, hs:hs + crop_size, ws:ws + crop_size] += scoremap
 
-    merge_img = merge_img / tot_score
-    return merge_img
+def fast_merge(split_data, starts, resolution):
+    """快速合并，避免复杂权重计算"""
+    B, C, H, W = resolution
+    result = torch.zeros((B, C, H, W))
+    count = torch.zeros((B, C, H, W))
 
+    for patch, (h_start, w_start) in zip(split_data, starts):
+        patch_h, patch_w = patch.shape[2], patch.shape[3]
+        h_end = min(h_start + patch_h, H)
+        w_end = min(w_start + patch_w, W)
 
-def init():
-    """初始化三个模型"""
-    global dehaze_model, demoiring_model, deblur_model
+        actual_h = h_end - h_start
+        actual_w = w_end - w_start
 
-    # 初始化去雾模型
-    try:
-        print("正在加载去雾模型...")
-        dehaze_cfg = yaml.safe_load(open("./option/RealDehazing_FPro.yml", "r"))['network_g']
-        dehaze_cfg.pop('type', None)
-        dehaze_model = FPro(**dehaze_cfg)
-        dehaze_model = dehaze_model.to(device)
-        dehaze_ckpt = torch.load("./model/synDehaze.pth", map_location='cpu')
-        dehaze_model.load_state_dict(dehaze_ckpt['params'])
-        dehaze_model.eval()
-        dehaze_model = dehaze_model.cpu()
-        print("去雾模型加载成功！")
-    except Exception as e:
-        print(f"去雾模型加载失败: {e}")
-        dehaze_model = None
+        result[:, :, h_start:h_end, w_start:w_end] += patch[:, :, :actual_h, :actual_w]
+        count[:, :, h_start:h_end, w_start:w_end] += 1
+
+    # 避免除零
+    result = result / torch.clamp(count, min=1)
+    return result
+
+
+def memory_cleanup():
+    """内存清理"""
+    gc.collect()
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache()
 
-    # 初始化去摩尔纹模型
-    try:
-        print("正在加载去摩尔纹模型...")
-        # 尝试加载YAML配置文件
-        try:
-            demoiring_cfg = yaml.safe_load(open("./option/RealDemoiring_FPro.yml", "r"))['network_g']
-            demoiring_cfg.pop('type', None)
-        except FileNotFoundError:
-            # 如果没有单独的配置文件，使用默认配置
-            print("未找到去摩尔纹配置文件，使用默认配置")
-            demoiring_cfg = {
-                'inp_channels': 3,
-                'out_channels': 3,
-                'dim': 48,
-                'num_blocks': [4, 6, 6, 8],
-                'num_refinement_blocks': 4,
-                'heads': [1, 2, 4, 8],
-                'ffn_expansion_factor': 2.66,
-                'bias': False,
-                'LayerNorm_type': 'WithBias',
-                'dual_pixel_task': False
-            }
-
-        demoiring_model = FPro(**demoiring_cfg)
-        demoiring_model = demoiring_model.to(device)
-        demoiring_ckpt = torch.load("./model/demoire_noAug.pth", map_location='cpu')
-        demoiring_model.load_state_dict(demoiring_ckpt['params'])
-        demoiring_model.eval()
-        demoiring_model = demoiring_model.cpu()
-        print("去摩尔纹模型加载成功！")
-    except Exception as e:
-        print(f"去摩尔纹模型加载失败: {e}")
-        demoiring_model = None
 
-    # 初始化运动去模糊模型
+def load_model_minimal(config_path, weight_path, default_config):
+    """最小化模型加载"""
     try:
-        print("正在加载运动去模糊模型...")
-        # 尝试加载YAML配置文件
+        # 尝试加载配置
         try:
-            deblur_cfg = yaml.safe_load(open("./option/Deblurring_FPro.yml", "r"))['network_g']
-            deblur_cfg.pop('type', None)
-        except FileNotFoundError:
-            # 如果没有单独的配置文件，使用默认配置
-            print("未找到运动去模糊配置文件，使用默认配置")
-            deblur_cfg = {
-                'inp_channels': 3,
-                'out_channels': 3,
-                'dim': 48,
-                'num_blocks': [4, 6, 6, 8],
-                'num_refinement_blocks': 4,
-                'heads': [1, 2, 4, 8],
-                'ffn_expansion_factor': 2.66,
-                'bias': False,
-                'LayerNorm_type': 'WithBias',
-                'dual_pixel_task': False
-            }
-
-        deblur_model = FPro(**deblur_cfg)
-        deblur_model = deblur_model.to(device)
-        deblur_ckpt = torch.load("./model/deblur.pth", map_location='cpu')
-        deblur_model.load_state_dict(deblur_ckpt['params'])
-        deblur_model.eval()
-        deblur_model = deblur_model.cpu()
-        print("运动去模糊模型加载成功！")
+            with open(config_path, 'r') as f:
+                cfg = yaml.safe_load(f)['network_g']
+                cfg.pop('type', None)
+        except:
+            print(f"使用默认配置: {config_path}")
+            cfg = default_config
+
+        # 创建模型
+        model = FPro(**cfg)
+
+        # 加载权重
+        checkpoint = torch.load(weight_path, map_location='cpu')
+        if 'params' in checkpoint:
+            model.load_state_dict(checkpoint['params'])
+        else:
+            model.load_state_dict(checkpoint)
+
+        model.eval()
+
+        # 尝试JIT优化（如果失败就用原始模型）
+        try:
+            sample_input = torch.randn(1, 3, 128, 128)
+            with torch.no_grad():
+                traced_model = torch.jit.trace(model, sample_input)
+                traced_model.eval()
+                print("JIT优化成功")
+                return traced_model
+        except:
+            print("JIT优化失败，使用原始模型")
+            return model
+
     except Exception as e:
-        print(f"运动去模糊模型加载失败: {e}")
-        deblur_model = None
-
-
-def inference(body: bytes, task_type: str = "dehaze") -> bytes:
-    """
-    推理函数：支持去雾、去摩尔纹和运动去模糊
-
-    Args:
-        body: 图像字节流
-        task_type: 任务类型，"dehaze"、"demoiring" 或 "deblur"
-
-    Returns:
-        处理后的图像字节流
-    """
-    # 选择对应的模型和参数
-    if task_type == "dehaze":
-        if dehaze_model is None:
-            raise Exception("去雾模型未加载")
-        model = dehaze_model
-        # 去雾任务的参数
-        crop_size_arg = 256
-        overlap_size_arg = 158
-    elif task_type == "demoiring":
-        if demoiring_model is None:
-            raise Exception("去摩尔纹模型未加载")
-        model = demoiring_model
-        # 去摩尔纹任务的参数
-        crop_size_arg = 256
-        overlap_size_arg = 200
-    elif task_type == "deblur":
-        if deblur_model is None:
-            raise Exception("运动去模糊模型未加载")
-        model = deblur_model
-        # 运动去模糊任务的参数
-        crop_size_arg = 256
-        overlap_size_arg = 200
-    else:
-        raise Exception(f"不支持的任务类型: {task_type}")
+        print(f"模型加载失败: {e}")
+        return None
 
-    # 加载输入图
+
+def init():
+    """优化的初始化函数"""
+    global dehaze_model, demoiring_model, deblur_model
+
+    print("HuggingFace Spaces 极限优化模式启动...")
+
+    # 默认配置
+    default_config = {
+        'inp_channels': 3,
+        'out_channels': 3,
+        'dim': 48,
+        'num_blocks': [4, 6, 6, 8],
+        'num_refinement_blocks': 4,
+        'heads': [1, 2, 4, 8],
+        'ffn_expansion_factor': 2.66,
+        'bias': False,
+        'LayerNorm_type': 'WithBias',
+        'dual_pixel_task': False
+    }
+
+    # 去雾模型
+    print("加载去雾模型...")
+    dehaze_model = load_model_minimal(
+        "./option/RealDehazing_FPro.yml",
+        "./model/synDehaze.pth",
+        default_config
+    )
+
+    # 去摩尔纹模型
+    print("加载去摩尔纹模型...")
+    demoiring_model = load_model_minimal(
+        "./option/RealDemoiring_FPro.yml",
+        "./model/demoire_noAug.pth",
+        default_config
+    )
+
+    # 运动去模糊模型
+    print("加载运动去模糊模型...")
+    deblur_model = load_model_minimal(
+        "./option/Deblurring_FPro.yml",
+        "./model/deblur.pth",
+        default_config
+    )
+
+    memory_cleanup()
+    print("模型初始化完成")
+
+
+def ultra_fast_inference(body: bytes, task_type: str = "dehaze") -> bytes:
+    """超快推理模式"""
+    # 选择模型
+    model_map = {
+        "dehaze": dehaze_model,
+        "demoiring": demoiring_model,
+        "deblur": deblur_model
+    }
+
+    model = model_map.get(task_type)
+    if model is None:
+        raise Exception(f"{task_type}模型未加载")
+
+    # 加载图像
     img = Image.open(BytesIO(body)).convert("RGB")
+    print(f"原始尺寸: {img.size}")
+
+    # 激进缩放
+    img = aggressive_image_resize(img, EXTREME_OPTIMIZATION['max_image_size'])
+
+    # 转换为张量
     arr = np.float32(img) / 255.0
     t = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
 
-    # 确保张量在 CPU 上
-    t = t.to(device)
-
-    # Padding in case images are not multiples of 8
-    factor = 8
+    # 最小padding
     h, w = t.shape[2], t.shape[3]
-    H = ((h + factor) // factor) * factor
-    W = ((w + factor) // factor) * factor
-    padh = H - h if h % factor != 0 else 0
-    padw = W - w if w % factor != 0 else 0
-    t = F.pad(t, (0, padw, 0, padh), 'reflect')
+    pad_h = (8 - h % 8) % 8
+    pad_w = (8 - w % 8) % 8
+
+    if pad_h > 0 or pad_w > 0:
+        t = F.pad(t, (0, pad_w, 0, pad_h), 'reflect')
 
     B, C, H, W = t.shape
 
-    # 如果图像小于等于切块大小，直接处理
-    if H <= crop_size_arg and W <= crop_size_arg:
-        with torch.no_grad():
+    # 推理
+    with torch.no_grad():
+        if H <= 256 and W <= 256:
+            # 小图像直接处理
             restored = model(t)
-    else:
-        # 使用切块逻辑
-        split_data, starts = splitimage(t, crop_size=crop_size_arg, overlap_size=overlap_size_arg)
+        else:
+            # 最小化切块处理
+            split_data, starts = minimal_splitimage(t, EXTREME_OPTIMIZATION['max_tiles'])
 
-        # 对每个切块进行推理
-        with torch.no_grad():
-            for i, data in enumerate(split_data):
-                data = data.to(device)
-                split_data[i] = model(data).cpu()
+            # 逐个处理切块
+            processed_data = []
+            for i, patch in enumerate(split_data):
+                if i > 0:  # 每处理一个切块就清理内存
+                    memory_cleanup()
 
-        # 合并结果
-        restored = mergeimage(split_data, starts, crop_size=crop_size_arg, resolution=(B, C, H, W))
-        restored = restored.to(device)
+                processed = model(patch)
+                processed_data.append(processed)
 
-    # Unpad images to original dimensions
+            # 快速合并
+            restored = fast_merge(processed_data, starts, (B, C, H, W))
+
+    # 去除padding
     restored = restored[:, :, :h, :w]
 
-    # 输出处理
-    merged = torch.clamp(restored, 0, 1).squeeze(0).permute(1, 2, 0).numpy()
-    merged = (merged * 255).astype(np.uint8)
+    # 快速后处理
+    result = torch.clamp(restored, 0, 1).squeeze(0).permute(1, 2, 0).numpy()
+    result = (result * 255).astype(np.uint8)
 
-    # 输出 PNG
-    out_img = Image.fromarray(merged)
+    # 输出
+    out_img = Image.fromarray(result)
     buf = BytesIO()
-    out_img.save(buf, format="PNG")
+    out_img.save(buf, format="PNG", optimize=True)
+
+    memory_cleanup()
     return buf.getvalue()
 
 
+# 导出函数
 def dehaze_inference(body: bytes) -> bytes:
-    """去雾推理的便捷函数"""
-    return inference(body, task_type="dehaze")
+    return ultra_fast_inference(body, "dehaze")
 
 
 def demoiring_inference(body: bytes) -> bytes:
-    """去摩尔纹推理的便捷函数"""
-    return inference(body, task_type="demoiring")
+    return ultra_fast_inference(body, "demoiring")
 
 
 def deblur_inference(body: bytes) -> bytes:
-    """运动去模糊推理的便捷函数"""
-    return inference(body, task_type="deblur")
+    return ultra_fast_inference(body, "deblur")
 
 
 def get_model_status():
-    """获取模型加载状态"""
     return {
         "dehaze_model_loaded": dehaze_model is not None,
         "demoiring_model_loaded": demoiring_model is not None,