init repo

.claude/CLAUDE.md

@@ -0,0 +1,6 @@
+To use this application (linch97/UltraSharpV2: Upscale image with UltraSharpV2 model):
+API schema: GET https://linch97-ultrasharpv2.hf.space/gradio_api/info
+Call endpoint: POST https://linch97-ultrasharpv2.hf.space/gradio_api/call/v2/{endpoint} {"param_name": value, ...}
+Poll result: GET https://linch97-ultrasharpv2.hf.space/gradio_api/call/{endpoint}/{event_id}
+File inputs: POST https://linch97-ultrasharpv2.hf.space/gradio_api/upload -F "files=@file.ext", use as: {"path": "<returned-path>", "meta": {"\_type": "gradio.FileData"}, "orig_name": "file.ext"}
+Auth: Bearer $HF_TOKEN (https://huggingface.co/settings/tokens)

app.py

@@ -0,0 +1,132 @@
+"""
+UltraSharp V2 — 图像超分辨率 Gradio 应用
+==========================================
+
+## 模型来源
+
+   默认从 Kim2091/UltraSharpV2 公开仓库下载 4x-UltraSharpV2.pth，
+   自动缓存到 ~/.cache/huggingface/hub/，无需手动上传。
+
+## 可选环境变量
+
+   MODEL_REPO_ID    覆盖默认仓库（默认 Kim2091/UltraSharpV2）
+   MODEL_FILENAME   覆盖默认文件名（默认 4x-UltraSharpV2.pth）
+   HF_ENDPOINT      镜像站，如 https://hf-mirror.com（国内加速）
+   HF_TOKEN         私有仓库的 token（公开仓库无需设置）
+
+## 本地运行
+
+   python app.py
+   # 国内镜像: HF_ENDPOINT=https://hf-mirror.com python app.py
+
+## 部署到 HuggingFace Space
+
+   1. 在 Space 设置中将 Hardware 选为 ZeroGPU
+   2. 无需设置 Secrets（模型来自公开仓库）
+   3. 如需国内镜像，添加 Secret: HF_ENDPOINT = https://hf-mirror.com
+"""
+
+import os
+import gradio as gr
+from model_loader import UltraSharpV2
+
+# ---------------------------------------------------------------------------
+# ZeroGPU 兼容层
+# ---------------------------------------------------------------------------
+try:
+    import spaces
+
+    _zerogpu = spaces.GPU(duration=120)  # 最长 GPU 占用 120s
+    IN_ZEROGPU = bool(os.environ.get("SPACES_ZERO_GPU"))
+except ImportError:
+    spaces = None
+    _zerogpu = None
+    IN_ZEROGPU = False
+
+
+def _gpu(fn):
+    """安全地应用 @spaces.GPU 装饰器（本地开发时退化为无操作）。"""
+    return _zerogpu(fn) if _zerogpu is not None else fn
+
+
+# ---------------------------------------------------------------------------
+# 模型：始终在 CPU 上加载（ZeroGPU 启动时 GPU 不可用）
+# ---------------------------------------------------------------------------
+model = UltraSharpV2(device="cpu")
+
+
+# ---------------------------------------------------------------------------
+# 推理函数（生成器模式 — ZeroGPU 硬性要求）
+# ---------------------------------------------------------------------------
+@_gpu
+def on_upscale(image, tile_size, tile_overlap, target_scale):
+    if image is None:
+        yield None, "请先上传图片"
+        return
+
+    model.to_cuda()
+    try:
+        result, elapsed = model.upscale(
+            image, int(tile_size), int(tile_overlap), float(target_scale)
+        )
+    finally:
+        model.to_cpu()
+
+    yield result, f"耗时: {elapsed:.2f}s"
+
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+with gr.Blocks(title="UltraSharp V2") as demo:
+    device_display = "ZeroGPU" if IN_ZEROGPU else model.device.upper()
+    gr.Markdown("# UltraSharp V2 - 图像超分辨率")
+    gr.Markdown(f"**运行设备**: {device_display} | **模型原生倍率**: {model.scale}x")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            input_img = gr.Image(label="输入图片", type="pil", height=400)
+            target_scale = gr.Slider(
+                label="放大倍率",
+                minimum=1.0,
+                maximum=4.0,
+                value=4.0,
+                step=0.05,
+                info="> 模型原生倍率时, 输出先 4x 推理再 Lanczos 缩放",
+            )
+            tile_size = gr.Slider(
+                label="tile_size",
+                minimum=128,
+                maximum=1024,
+                value=512,
+                step=32,
+                info="分块大小，越小越省显存",
+            )
+            tile_overlap = gr.Slider(
+                label="tile_overlap",
+                minimum=0,
+                maximum=128,
+                value=32,
+                step=8,
+                info="块间重叠像素",
+            )
+
+        with gr.Column(scale=1):
+            run_btn = gr.Button("开始推理", variant="primary")
+            output_img = gr.Image(label="推理结果", height=400)
+            status = gr.Textbox(label="状态", interactive=False)
+
+    run_btn.click(
+        fn=on_upscale,
+        inputs=[input_img, tile_size, tile_overlap, target_scale],
+        outputs=[output_img, status],
+    )
+
+
+# ---------------------------------------------------------------------------
+# ZeroGPU 必须启用 queue（默认并发 1，队列上限 10）
+# ---------------------------------------------------------------------------
+demo.queue(max_size=10, default_concurrency_limit=1)
+
+if __name__ == "__main__":
+    demo.launch()

model_loader.py

@@ -0,0 +1,215 @@
+import os
+import time
+import torch
+import numpy as np
+from PIL import Image
+
+
+def detect_device():
+    """Auto-detect device. Returns CPU on ZeroGPU (GPU not available at startup)."""
+    if torch.cuda.is_available():
+        return "cuda", torch.float16
+    return "cpu", torch.float32
+
+
+# ---------------------------------------------------------------------------
+# HuggingFace Hub 模型下载
+# ---------------------------------------------------------------------------
+# 默认从 Kim2091/UltraSharpV2 公开仓库下载，可通过环境变量覆盖:
+#   MODEL_REPO_ID    - 覆盖默认仓库 ID
+#   MODEL_FILENAME   - 覆盖默认文件名
+#   HF_ENDPOINT      - 镜像站地址，如 https://hf-mirror.com（国内加速）
+#   HF_TOKEN         - 私有仓库的 token（公开仓库无需设置）
+# ---------------------------------------------------------------------------
+
+_DEFAULT_REPO_ID = "Kim2091/UltraSharpV2"
+_DEFAULT_FILENAME = "4x-UltraSharpV2.pth"
+
+MODEL_CANDIDATES = [
+    "4x-UltraSharpV2.pth",
+    "4x-UltraSharpV2.safetensors",
+    "4x-UltraSharpV2.pt",
+]
+
+
+def _download_from_hub(repo_id: str, filename: str) -> str:
+    """从 HuggingFace Hub 下载模型文件（自动缓存，重复调用不重新下载）。"""
+    from huggingface_hub import hf_hub_download
+
+    token = os.environ.get("HF_TOKEN")
+    endpoint = os.environ.get("HF_ENDPOINT")
+    if endpoint:
+        print(f"[UltraSharpV2] 使用镜像: {endpoint}")
+
+    print(f"[UltraSharpV2] 从 HF Hub 下载: {repo_id}/{filename}")
+    path = hf_hub_download(
+        repo_id=repo_id,
+        filename=filename,
+        token=token,
+        endpoint=endpoint,
+    )
+    print(f"[UltraSharpV2] 下载成功: {path}")
+    return path
+
+
+def _resolve_model_path() -> str:
+    """按优先级解析模型路径: 本地文件 > HF Hub（默认 Kim2091/UltraSharpV2）。"""
+    # 1) 本地文件优先（存在则直接使用，跳过网络）
+    for name in MODEL_CANDIDATES:
+        if os.path.exists(name):
+            print(f"[UltraSharpV2] 使用本地模型: {name}")
+            return name
+
+    # 2) 从 HF Hub 下载
+    repo_id = os.environ.get("MODEL_REPO_ID", _DEFAULT_REPO_ID)
+    filename = os.environ.get("MODEL_FILENAME", _DEFAULT_FILENAME)
+    return _download_from_hub(repo_id, filename)
+
+
+class UltraSharpV2:
+    def __init__(self, model_path=None, device=None):
+        """
+        Args:
+            model_path: path to model file (auto-resolve from HF Hub or local if None).
+            device: "cpu" (ZeroGPU default), "cuda", or None (auto-detect).
+        """
+        if model_path is None:
+            model_path = _resolve_model_path()
+
+        if device is not None:
+            self.device = device
+            self.dtype = torch.float16 if device == "cuda" else torch.float32
+        else:
+            self.device, self.dtype = detect_device()
+
+        self._model_path = model_path
+        self.model = self._load_model(model_path)
+        self.scale = self.model.scale
+        print(f"[UltraSharpV2] 设备: {self.device}, 精度: {self.dtype}")
+        print(f"[UltraSharpV2] 模型加载完毕, 放大倍率: {self.scale}x")
+
+    def _load_model(self, path):
+        from spandrel import ModelLoader
+
+        loader = ModelLoader()
+        model = loader.load_from_file(path)
+        model.model.to(self.device).to(self.dtype).eval()
+        return model
+
+    def to_cuda(self):
+        """Move model to CUDA (called inside @spaces.GPU decorated function)."""
+        if self.device == "cuda":
+            return
+        print("[UltraSharpV2] 正在将模型移至 GPU ...")
+        self.device = "cuda"
+        self.dtype = torch.float16
+        self.model.model.to(self.device).to(self.dtype)
+        torch.cuda.empty_cache()
+
+    def to_cpu(self):
+        """Move model back to CPU to release ZeroGPU memory."""
+        if self.device == "cpu":
+            return
+        print("[UltraSharpV2] 正在将模型移回 CPU ...")
+        self.model.model.to("cpu").to(torch.float32)
+        self.device = "cpu"
+        self.dtype = torch.float32
+        torch.cuda.empty_cache()
+
+    def upscale(
+        self,
+        image: Image.Image,
+        tile_size: int = 512,
+        tile_overlap: int = 32,
+        target_scale: float = 4.0,
+    ) -> tuple[Image.Image, float]:
+        start = time.time()
+
+        tensor = self._pil_to_tensor(image)
+        _, _, h, w = tensor.shape
+
+        if h <= tile_size and w <= tile_size:
+            with torch.no_grad():
+                output = self.model(tensor.to(self.dtype)).float()
+        else:
+            output = self._tiled_upscale(tensor, tile_size, tile_overlap)
+
+        result = self._tensor_to_pil(output)
+
+        if target_scale > 0 and abs(target_scale - self.scale) > 0.01:
+            dest_w = int(w * target_scale)
+            dest_h = int(h * target_scale)
+            result = result.resize((dest_w, dest_h), Image.LANCZOS)
+
+        elapsed = time.time() - start
+        print(
+            f"[UltraSharpV2] 推理完成, 尺寸: {h}x{w} -> {result.width}x{result.height}, 耗时: {elapsed:.2f}s"
+        )
+        return result, elapsed
+
+    def _pil_to_tensor(self, img: Image.Image) -> torch.Tensor:
+        if img.mode != "RGB":
+            img = img.convert("RGB")
+        arr = np.array(img).astype(np.float32) / 255.0
+        tensor = torch.from_numpy(arr).permute(2, 0, 1).unsqueeze(0)
+        return tensor.to(self.device)
+
+    def _tensor_to_pil(self, tensor: torch.Tensor) -> Image.Image:
+        tensor = tensor.squeeze(0).float().clamp(0, 1)
+        arr = (tensor.permute(1, 2, 0).cpu().numpy() * 255).round().astype(np.uint8)
+        return Image.fromarray(arr)
+
+    def _tiled_upscale(
+        self, tensor: torch.Tensor, tile_size: int, tile_overlap: int
+    ) -> torch.Tensor:
+        _, c, h, w = tensor.shape
+        scale = self.scale
+        pad = min(tile_overlap, tile_size // 4)
+
+        padded = torch.nn.functional.pad(
+            tensor, (pad, pad, pad, pad), mode="reflect"
+        )
+        _, _, hp, wp = padded.shape
+
+        out_tile = tile_size * scale
+        out_hp = hp * scale
+        out_wp = wp * scale
+        stride = tile_size - pad * 2
+
+        output = torch.zeros(1, c, out_hp, out_wp, device=self.device, dtype=torch.float32)
+        weight = torch.zeros(1, 1, out_hp, out_wp, device=self.device, dtype=torch.float32)
+
+        wy = torch.ones(out_tile, device=self.device)
+        wx = torch.ones(out_tile, device=self.device)
+        if pad > 0:
+            ramp = torch.linspace(0, 1, pad * scale, device=self.device)
+            wy[: pad * scale] = ramp
+            wy[-pad * scale :] = ramp.flip(0)
+            wx[: pad * scale] = ramp
+            wx[-pad * scale :] = ramp.flip(0)
+        wmap = wy.view(1, 1, -1, 1) * wx.view(1, 1, 1, -1)
+
+        for y in range(0, hp, stride):
+            for x in range(0, wp, stride):
+                y1 = min(y + tile_size, hp)
+                x1 = min(x + tile_size, wp)
+                y0 = max(0, y1 - tile_size)
+                x0 = max(0, x1 - tile_size)
+
+                tile = padded[:, :, y0:y1, x0:x1]
+                with torch.no_grad():
+                    out = self.model(tile.to(self.dtype)).float()
+
+                oh, ow = out.shape[2], out.shape[3]
+                oy0, ox0 = y0 * scale, x0 * scale
+                wc = wmap[:, :, :oh, :ow]
+
+                output[:, :, oy0 : oy0 + oh, ox0 : ox0 + ow] += out * wc
+                weight[:, :, oy0 : oy0 + oh, ox0 : ox0 + ow] += wc
+
+        output /= weight.clamp(min=1e-8)
+
+        crop_start = pad * scale
+        crop_end_h = crop_start + h * scale
+        crop_end_w = crop_start + w * scale
+        return output[:, :, crop_start:crop_end_h, crop_start:crop_end_w]

requirements.txt

@@ -0,0 +1,6 @@
+torch>=2.0
+spandrel>=0.3
+gradio>=4.0
+Pillow
+huggingface_hub
+spaces>=0.3