Deploy Real-CUGAN control plane with bundled weights

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+.venv/
+app/__pycache__/
+app/vendor/__pycache__/
+data/*.db

Dockerfile

@@ -0,0 +1,29 @@
+FROM python:3.11-slim
+
+ENV DEBIAN_FRONTEND=noninteractive
+ENV PIP_NO_CACHE_DIR=1
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libgomp1 \
+    curl \
+    ca-certificates \
+    && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY requirements.txt /app/requirements.txt
+
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir torch==2.5.1 --index-url https://download.pytorch.org/whl/cpu \
+    && pip install --no-cache-dir -r /app/requirements.txt
+
+COPY app /app/app
+COPY weights /app/weights
+COPY README.md /app/README.md
+
+RUN mkdir -p /app/data /app/app/vendor
+
+EXPOSE 7860
+
+CMD ["uvicorn", "app.main:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -1,10 +1,89 @@
 ---
-title: Real Cugan Hf Api
-emoji: 🌖
-colorFrom: pink
-colorTo: purple
+title: Real-CUGAN Control Plane
+emoji: 🖼️
+colorFrom: yellow
+colorTo: green
 sdk: docker
-pinned: false
+app_port: 7860
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Real-CUGAN Control Plane
+
+CPU-first Hugging Face Space for anime image upscaling with:
+
+- API key protected `/api/v1/upscale`
+- Admin login, key management, runtime controls
+- Job history and lightweight dashboard
+- Real-CUGAN lazy loading on CPU
+
+## Required setup
+
+1. Put one or more Real-CUGAN weight files into `weights/`.
+2. Set `ADMIN_PASSWORD` as a Hugging Face Space secret.
+3. Optional: set `SESSION_SECRET`, `BOOTSTRAP_API_KEY`, `REAL_CUGAN_WEIGHT_BASE_URL`.
+
+Recommended Hugging Face Space secrets:
+
+- `ADMIN_PASSWORD`: required unless you want to initialize the admin account in the browser
+- `SESSION_SECRET`: recommended for stable admin sessions across restarts
+- `BOOTSTRAP_API_KEY`: optional first API key created at boot
+- `BOOTSTRAP_API_KEY_NAME`: optional label for the bootstrap key
+- `REAL_CUGAN_WEIGHT_BASE_URL`: optional base URL if you host weights remotely
+- `SESSION_HTTPS_ONLY=true`: recommended once the Space is running behind HTTPS
+
+Recommended 2x weights:
+
+- `up2x-latest-no-denoise.pth`
+- `up2x-latest-denoise1x.pth`
+- `up2x-latest-denoise2x.pth`
+- `up2x-latest-denoise3x.pth`
+- `up2x-latest-conservative.pth`
+
+Optional 3x / 4x weights:
+
+- `up3x-latest-no-denoise.pth`
+- `up3x-latest-denoise3x.pth`
+- `up3x-latest-conservative.pth`
+- `up4x-latest-no-denoise.pth`
+- `up4x-latest-denoise3x.pth`
+- `up4x-latest-conservative.pth`
+
+## API
+
+Use either `X-API-Key: <key>` or `Authorization: Bearer <key>`.
+
+`POST /api/v1/upscale`
+
+Multipart form fields:
+
+- `file`: source image
+- `scale`: `2`, `3`, `4`
+- `variant`: `no-denoise`, `denoise1x`, `denoise2x`, `denoise3x`, `conservative`
+- `alpha`: `0.75` to `1.3`
+- `tile_mode`: optional override
+- `cache_mode`: optional override
+- `response_format`: `png`, `jpeg`, `webp`
+
+The admin panel is at `/admin`.
+
+## Local run
+
+```bash
+cd /home/huanx/code/real-cugan-hf-api
+python -m venv .venv
+source .venv/bin/activate
+pip install --upgrade pip
+pip install torch==2.5.1 --index-url https://download.pytorch.org/whl/cpu
+pip install -r requirements.txt
+export ADMIN_PASSWORD='change-me-now'
+uvicorn app.main:app --host 0.0.0.0 --port 7860
+```
+
+Open `http://127.0.0.1:7860/admin`.
+
+## Notes
+
+- The app stores only metadata in SQLite. Uploaded images are processed in memory and are not persisted by default.
+- The runtime loads `upcunet_v3.py` from the pinned Real-CUGAN upstream commit on first use and verifies its checksum.
+- API requests are serialized. One active upscale runs at a time by design.
+- Without CPU PyTorch or missing weights, the API responds with a clear `503` describing the runtime issue.

app/__init__.py

@@ -0,0 +1 @@
+"""Real-CUGAN control plane package."""

app/config.py

@@ -0,0 +1,202 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+import os
+import secrets
+
+
+def _bool_env(name: str, default: bool) -> bool:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    return value.strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _int_env(name: str, default: int) -> int:
+    value = os.getenv(name)
+    if value is None:
+        return default
+    try:
+        return int(value)
+    except ValueError:
+        return default
+
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent
+DATA_DIR = PROJECT_ROOT / "data"
+WEIGHTS_DIR = PROJECT_ROOT / "weights"
+VENDOR_DIR = PROJECT_ROOT / "app" / "vendor"
+
+REAL_CUGAN_COMMIT = "2799af78ef105b414cc4b796c67c8511acdcdf6f"
+REAL_CUGAN_SHA256 = "ef6c4e433bcac37b75ffba0a4044987ddd3ecfe7765a74a3c93887954e45562b"
+
+
+MODEL_CATALOG = {
+    2: {
+        "no-denoise": [
+            "up2x-latest-no-denoise.pth",
+            "up2x-no-denoise.pth",
+        ],
+        "denoise1x": [
+            "up2x-latest-denoise1x.pth",
+        ],
+        "denoise2x": [
+            "up2x-latest-denoise2x.pth",
+        ],
+        "denoise3x": [
+            "up2x-latest-denoise3x.pth",
+        ],
+        "conservative": [
+            "up2x-latest-conservative.pth",
+        ],
+    },
+    3: {
+        "no-denoise": [
+            "up3x-latest-no-denoise.pth",
+            "up3x-no-denoise.pth",
+        ],
+        "denoise3x": [
+            "up3x-latest-denoise3x.pth",
+        ],
+        "conservative": [
+            "up3x-latest-conservative.pth",
+        ],
+    },
+    4: {
+        "no-denoise": [
+            "up4x-latest-no-denoise.pth",
+            "up4x-no-denoise.pth",
+        ],
+        "denoise3x": [
+            "up4x-latest-denoise3x.pth",
+        ],
+        "conservative": [
+            "up4x-latest-conservative.pth",
+        ],
+    },
+}
+
+
+RUNTIME_FIELD_SPECS = [
+    {
+        "name": "default_scale",
+        "label": "Default scale",
+        "type": "select",
+        "options": ["2", "3", "4"],
+        "help": "Fallback scale when the API request omits it.",
+    },
+    {
+        "name": "default_variant",
+        "label": "Default variant",
+        "type": "select",
+        "options": [
+            "no-denoise",
+            "denoise1x",
+            "denoise2x",
+            "denoise3x",
+            "conservative",
+        ],
+        "help": "Default Real-CUGAN weight profile.",
+    },
+    {
+        "name": "default_alpha",
+        "label": "Alpha",
+        "type": "float",
+        "help": "Enhancement strength. Official safe range is 0.75 to 1.3.",
+    },
+    {
+        "name": "default_tile_mode",
+        "label": "Tile mode",
+        "type": "int",
+        "help": "0 prefers whole-image inference. Higher values trade speed for memory safety.",
+    },
+    {
+        "name": "default_cache_mode",
+        "label": "Cache mode",
+        "type": "select",
+        "options": ["0", "1"],
+        "help": "1 is slower but safer under memory pressure on CPU.",
+    },
+    {
+        "name": "max_input_long_edge",
+        "label": "Max input long edge",
+        "type": "int",
+        "help": "Requests above this are rejected before inference.",
+    },
+    {
+        "name": "max_input_pixels",
+        "label": "Max input pixels",
+        "type": "int",
+        "help": "Absolute input pixel cap for CPU safety.",
+    },
+    {
+        "name": "jpeg_quality",
+        "label": "JPEG quality",
+        "type": "int",
+        "help": "Applied when the response format is jpeg.",
+    },
+]
+
+
+DEFAULT_RUNTIME_SETTINGS = {
+    "default_scale": "2",
+    "default_variant": "no-denoise",
+    "default_alpha": "1.0",
+    "default_tile_mode": "3",
+    "default_cache_mode": "1",
+    "max_input_long_edge": "1536",
+    "max_input_pixels": "2400000",
+    "jpeg_quality": "95",
+}
+
+
+@dataclass(slots=True)
+class EnvSettings:
+    app_name: str
+    host: str
+    port: int
+    database_path: Path
+    data_dir: Path
+    weights_dir: Path
+    vendor_dir: Path
+    session_secret: str
+    session_https_only: bool
+    admin_username: str
+    admin_password: str
+    bootstrap_api_key: str
+    bootstrap_api_key_name: str
+    real_cugan_commit: str
+    real_cugan_sha256: str
+    real_cugan_upstream_url: str
+    real_cugan_weight_base_url: str
+
+
+def load_env_settings() -> EnvSettings:
+    DATA_DIR.mkdir(parents=True, exist_ok=True)
+    WEIGHTS_DIR.mkdir(parents=True, exist_ok=True)
+    VENDOR_DIR.mkdir(parents=True, exist_ok=True)
+    session_secret = os.getenv("SESSION_SECRET") or secrets.token_urlsafe(32)
+    commit = os.getenv("REAL_CUGAN_COMMIT", REAL_CUGAN_COMMIT)
+    return EnvSettings(
+        app_name=os.getenv("APP_NAME", "Real-CUGAN Control Plane"),
+        host=os.getenv("HOST", "0.0.0.0"),
+        port=_int_env("PORT", 7860),
+        database_path=Path(os.getenv("DATABASE_PATH", DATA_DIR / "app.db")),
+        data_dir=DATA_DIR,
+        weights_dir=WEIGHTS_DIR,
+        vendor_dir=VENDOR_DIR,
+        session_secret=session_secret,
+        session_https_only=_bool_env("SESSION_HTTPS_ONLY", False),
+        admin_username=os.getenv("ADMIN_USERNAME", "admin"),
+        admin_password=os.getenv("ADMIN_PASSWORD", ""),
+        bootstrap_api_key=os.getenv("BOOTSTRAP_API_KEY", ""),
+        bootstrap_api_key_name=os.getenv("BOOTSTRAP_API_KEY_NAME", "primary"),
+        real_cugan_commit=commit,
+        real_cugan_sha256=os.getenv("REAL_CUGAN_SHA256", REAL_CUGAN_SHA256),
+        real_cugan_upstream_url=os.getenv(
+            "REAL_CUGAN_UPSTREAM_URL",
+            f"https://raw.githubusercontent.com/bilibili/ailab/{commit}/Real-CUGAN/upcunet_v3.py",
+        ),
+        real_cugan_weight_base_url=os.getenv("REAL_CUGAN_WEIGHT_BASE_URL", "").rstrip("/"),
+    )

app/db.py

@@ -0,0 +1,313 @@
+from __future__ import annotations
+
+import sqlite3
+import threading
+from pathlib import Path
+from typing import Any
+
+
+def utcnow_iso() -> str:
+    from datetime import datetime, timezone
+
+    return datetime.now(timezone.utc).replace(microsecond=0).isoformat()
+
+
+class Database:
+    def __init__(self, path: Path) -> None:
+        self.path = path
+        self.path.parent.mkdir(parents=True, exist_ok=True)
+        self._lock = threading.RLock()
+        self._conn = sqlite3.connect(self.path, check_same_thread=False)
+        self._conn.row_factory = sqlite3.Row
+
+    def close(self) -> None:
+        self._conn.close()
+
+    def initialize(self) -> None:
+        with self._lock:
+            self._conn.executescript(
+                """
+                PRAGMA journal_mode=WAL;
+
+                CREATE TABLE IF NOT EXISTS users (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    username TEXT NOT NULL UNIQUE,
+                    password_hash TEXT NOT NULL,
+                    is_admin INTEGER NOT NULL DEFAULT 1,
+                    created_at TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS api_keys (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    name TEXT NOT NULL,
+                    key_prefix TEXT NOT NULL UNIQUE,
+                    secret_hash TEXT NOT NULL,
+                    enabled INTEGER NOT NULL DEFAULT 1,
+                    created_at TEXT NOT NULL,
+                    last_used_at TEXT
+                );
+
+                CREATE TABLE IF NOT EXISTS app_settings (
+                    name TEXT PRIMARY KEY,
+                    value TEXT NOT NULL,
+                    updated_at TEXT NOT NULL
+                );
+
+                CREATE TABLE IF NOT EXISTS jobs (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    status TEXT NOT NULL,
+                    source_filename TEXT,
+                    input_sha256 TEXT,
+                    input_width INTEGER,
+                    input_height INTEGER,
+                    output_width INTEGER,
+                    output_height INTEGER,
+                    scale INTEGER,
+                    model_variant TEXT,
+                    alpha REAL,
+                    tile_mode_requested INTEGER,
+                    tile_mode_used INTEGER,
+                    cache_mode INTEGER,
+                    response_format TEXT,
+                    duration_ms INTEGER,
+                    error_message TEXT,
+                    created_at TEXT NOT NULL,
+                    started_at TEXT,
+                    finished_at TEXT
+                );
+                """
+            )
+            self._conn.commit()
+
+    def fetch_one(self, query: str, params: tuple[Any, ...] = ()) -> sqlite3.Row | None:
+        with self._lock:
+            return self._conn.execute(query, params).fetchone()
+
+    def fetch_all(self, query: str, params: tuple[Any, ...] = ()) -> list[sqlite3.Row]:
+        with self._lock:
+            return self._conn.execute(query, params).fetchall()
+
+    def execute(self, query: str, params: tuple[Any, ...] = ()) -> sqlite3.Cursor:
+        with self._lock:
+            cursor = self._conn.execute(query, params)
+            self._conn.commit()
+            return cursor
+
+    def ensure_admin_user(self, username: str, password_hash: str) -> None:
+        existing = self.fetch_one("SELECT id FROM users WHERE username = ?", (username,))
+        now = utcnow_iso()
+        if existing:
+            return
+        self.execute(
+            """
+            INSERT INTO users (username, password_hash, is_admin, created_at, updated_at)
+            VALUES (?, ?, 1, ?, ?)
+            """,
+            (username, password_hash, now, now),
+        )
+
+    def update_admin_password(self, username: str, password_hash: str) -> None:
+        self.execute(
+            "UPDATE users SET password_hash = ?, updated_at = ? WHERE username = ?",
+            (password_hash, utcnow_iso(), username),
+        )
+
+    def get_user_by_username(self, username: str) -> sqlite3.Row | None:
+        return self.fetch_one("SELECT * FROM users WHERE username = ?", (username,))
+
+    def get_user_by_id(self, user_id: int) -> sqlite3.Row | None:
+        return self.fetch_one("SELECT * FROM users WHERE id = ?", (user_id,))
+
+    def create_api_key(self, name: str, prefix: str, secret_hash: str) -> int:
+        cursor = self.execute(
+            """
+            INSERT INTO api_keys (name, key_prefix, secret_hash, enabled, created_at)
+            VALUES (?, ?, ?, 1, ?)
+            """,
+            (name, prefix, secret_hash, utcnow_iso()),
+        )
+        return int(cursor.lastrowid)
+
+    def find_api_key_by_prefix(self, prefix: str) -> sqlite3.Row | None:
+        return self.fetch_one("SELECT * FROM api_keys WHERE key_prefix = ?", (prefix,))
+
+    def touch_api_key(self, key_id: int) -> None:
+        self.execute(
+            "UPDATE api_keys SET last_used_at = ? WHERE id = ?",
+            (utcnow_iso(), key_id),
+        )
+
+    def list_api_keys(self) -> list[sqlite3.Row]:
+        return self.fetch_all(
+            "SELECT * FROM api_keys ORDER BY created_at DESC, id DESC"
+        )
+
+    def set_api_key_enabled(self, key_id: int, enabled: bool) -> None:
+        self.execute(
+            "UPDATE api_keys SET enabled = ? WHERE id = ?",
+            (1 if enabled else 0, key_id),
+        )
+
+    def delete_api_key(self, key_id: int) -> None:
+        self.execute("DELETE FROM api_keys WHERE id = ?", (key_id,))
+
+    def get_settings(self) -> dict[str, str]:
+        rows = self.fetch_all("SELECT name, value FROM app_settings")
+        return {row["name"]: row["value"] for row in rows}
+
+    def set_settings(self, values: dict[str, str]) -> None:
+        now = utcnow_iso()
+        with self._lock:
+            self._conn.executemany(
+                """
+                INSERT INTO app_settings (name, value, updated_at)
+                VALUES (?, ?, ?)
+                ON CONFLICT(name) DO UPDATE SET
+                    value = excluded.value,
+                    updated_at = excluded.updated_at
+                """,
+                [(name, value, now) for name, value in values.items()],
+            )
+            self._conn.commit()
+
+    def create_job(
+        self,
+        *,
+        status: str,
+        source_filename: str,
+        input_sha256: str,
+        input_width: int,
+        input_height: int,
+        scale: int,
+        model_variant: str,
+        alpha: float,
+        tile_mode_requested: int,
+        cache_mode: int,
+        response_format: str,
+    ) -> int:
+        cursor = self.execute(
+            """
+            INSERT INTO jobs (
+                status, source_filename, input_sha256, input_width, input_height,
+                scale, model_variant, alpha, tile_mode_requested, cache_mode,
+                response_format, created_at
+            )
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """,
+            (
+                status,
+                source_filename,
+                input_sha256,
+                input_width,
+                input_height,
+                scale,
+                model_variant,
+                alpha,
+                tile_mode_requested,
+                cache_mode,
+                response_format,
+                utcnow_iso(),
+            ),
+        )
+        return int(cursor.lastrowid)
+
+    def mark_job_running(self, job_id: int) -> None:
+        self.execute(
+            "UPDATE jobs SET status = 'running', started_at = ? WHERE id = ?",
+            (utcnow_iso(), job_id),
+        )
+
+    def mark_job_success(
+        self,
+        job_id: int,
+        *,
+        output_width: int,
+        output_height: int,
+        tile_mode_used: int,
+        duration_ms: int,
+    ) -> None:
+        self.execute(
+            """
+            UPDATE jobs
+            SET status = 'succeeded',
+                output_width = ?,
+                output_height = ?,
+                tile_mode_used = ?,
+                duration_ms = ?,
+                finished_at = ?
+            WHERE id = ?
+            """,
+            (
+                output_width,
+                output_height,
+                tile_mode_used,
+                duration_ms,
+                utcnow_iso(),
+                job_id,
+            ),
+        )
+
+    def mark_job_failed(self, job_id: int, error_message: str) -> None:
+        self.execute(
+            """
+            UPDATE jobs
+            SET status = 'failed',
+                error_message = ?,
+                finished_at = ?
+            WHERE id = ?
+            """,
+            (error_message[:800], utcnow_iso(), job_id),
+        )
+
+    def list_recent_jobs(self, limit: int = 25) -> list[sqlite3.Row]:
+        return self.fetch_all(
+            """
+            SELECT * FROM jobs
+            ORDER BY id DESC
+            LIMIT ?
+            """,
+            (limit,),
+        )
+
+    def dashboard_metrics(self) -> dict[str, Any]:
+        total_row = self.fetch_one(
+            """
+            SELECT
+                COUNT(*) AS total,
+                SUM(CASE WHEN status = 'succeeded' THEN 1 ELSE 0 END) AS succeeded,
+                SUM(CASE WHEN status = 'failed' THEN 1 ELSE 0 END) AS failed,
+                AVG(CASE WHEN duration_ms IS NOT NULL THEN duration_ms END) AS avg_duration_ms
+            FROM jobs
+            """
+        )
+        last_row = self.fetch_one(
+            """
+            SELECT finished_at
+            FROM jobs
+            WHERE status = 'succeeded'
+            ORDER BY id DESC
+            LIMIT 1
+            """
+        )
+        return {
+            "total": int(total_row["total"] or 0),
+            "succeeded": int(total_row["succeeded"] or 0),
+            "failed": int(total_row["failed"] or 0),
+            "avg_duration_ms": int(total_row["avg_duration_ms"] or 0),
+            "last_success_at": last_row["finished_at"] if last_row else None,
+        }
+
+    def daily_job_counts(self, days: int = 7) -> list[dict[str, Any]]:
+        rows = self.fetch_all(
+            """
+            SELECT substr(created_at, 1, 10) AS day, COUNT(*) AS count
+            FROM jobs
+            GROUP BY substr(created_at, 1, 10)
+            ORDER BY day DESC
+            LIMIT ?
+            """,
+            (days,),
+        )
+        ordered = list(reversed(rows))
+        return [{"day": row["day"], "count": int(row["count"])} for row in ordered]

app/main.py

@@ -0,0 +1,491 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+from fastapi import FastAPI, File, Form, HTTPException, Request, UploadFile
+from fastapi.responses import HTMLResponse, JSONResponse, RedirectResponse, Response
+from fastapi.staticfiles import StaticFiles
+from fastapi.templating import Jinja2Templates
+from starlette.middleware.sessions import SessionMiddleware
+
+from .config import DEFAULT_RUNTIME_SETTINGS, MODEL_CATALOG, RUNTIME_FIELD_SPECS, load_env_settings
+from .db import Database
+from .runtime import BusyError, RealCuganRuntime, RuntimeConfigurationError, UnsupportedModelError
+from .security import generate_api_key, generate_csrf_token, hash_secret, key_prefix, verify_secret
+
+
+env = load_env_settings()
+db = Database(env.database_path)
+db.initialize()
+runtime = RealCuganRuntime(env)
+
+templates = Jinja2Templates(directory=str(Path(__file__).resolve().parent / "templates"))
+
+app = FastAPI(title=env.app_name, docs_url=None, redoc_url=None)
+app.add_middleware(
+    SessionMiddleware,
+    secret_key=env.session_secret,
+    same_site="lax",
+    https_only=env.session_https_only,
+)
+app.mount("/static", StaticFiles(directory=str(Path(__file__).resolve().parent / "static")), name="static")
+
+
+def now_local_text() -> str:
+    return datetime.now(timezone.utc).astimezone().strftime("%Y-%m-%d %H:%M:%S %Z")
+
+
+def initialize_defaults() -> None:
+    existing_settings = db.get_settings()
+    missing = {
+        name: value
+        for name, value in DEFAULT_RUNTIME_SETTINGS.items()
+        if name not in existing_settings
+    }
+    if missing:
+        db.set_settings(missing)
+    if env.admin_password:
+        user = db.get_user_by_username(env.admin_username)
+        if user is None:
+            db.ensure_admin_user(env.admin_username, hash_secret(env.admin_password))
+    if env.bootstrap_api_key:
+        prefix = key_prefix(env.bootstrap_api_key)
+        if db.find_api_key_by_prefix(prefix) is None:
+            db.create_api_key(env.bootstrap_api_key_name, prefix, hash_secret(env.bootstrap_api_key))
+
+
+initialize_defaults()
+
+
+def get_current_user(request: Request) -> dict[str, Any] | None:
+    user_id = request.session.get("user_id")
+    if not user_id:
+        return None
+    row = db.get_user_by_id(int(user_id))
+    return dict(row) if row else None
+
+
+def ensure_admin(request: Request) -> dict[str, Any]:
+    user = get_current_user(request)
+    if user is None:
+        raise HTTPException(status_code=401, detail="Admin login required.")
+    return user
+
+
+def redirect_to_login() -> RedirectResponse:
+    return RedirectResponse("/admin/login", status_code=303)
+
+
+def get_runtime_settings() -> dict[str, str]:
+    settings = DEFAULT_RUNTIME_SETTINGS.copy()
+    settings.update(db.get_settings())
+    return settings
+
+
+def typed_runtime_settings() -> dict[str, Any]:
+    raw = get_runtime_settings()
+    return {
+        "default_scale": int(raw["default_scale"]),
+        "default_variant": raw["default_variant"],
+        "default_alpha": float(raw["default_alpha"]),
+        "default_tile_mode": int(raw["default_tile_mode"]),
+        "default_cache_mode": int(raw["default_cache_mode"]),
+        "max_input_long_edge": int(raw["max_input_long_edge"]),
+        "max_input_pixels": int(raw["max_input_pixels"]),
+        "jpeg_quality": int(raw["jpeg_quality"]),
+    }
+
+
+def validate_settings_payload(payload: dict[str, str]) -> dict[str, str]:
+    scale = int(payload["default_scale"])
+    if scale not in {2, 3, 4}:
+        raise ValueError("Default scale must be 2, 3, or 4.")
+    variant = payload["default_variant"]
+    alpha = float(payload["default_alpha"])
+    tile_mode = int(payload["default_tile_mode"])
+    cache_mode = int(payload["default_cache_mode"])
+    max_edge = int(payload["max_input_long_edge"])
+    max_pixels = int(payload["max_input_pixels"])
+    jpeg_quality = int(payload["jpeg_quality"])
+    if alpha < 0.75 or alpha > 1.3:
+        raise ValueError("Alpha must stay between 0.75 and 1.3.")
+    if tile_mode < 0 or tile_mode > 5:
+        raise ValueError("Tile mode must be between 0 and 5.")
+    if cache_mode not in {0, 1}:
+        raise ValueError("Cache mode must be 0 or 1.")
+    if max_edge < 512 or max_edge > 4096:
+        raise ValueError("Max input long edge must stay between 512 and 4096.")
+    if max_pixels < 512 * 512 or max_pixels > 8_000_000:
+        raise ValueError("Max input pixels must stay between 262144 and 8000000.")
+    if jpeg_quality < 70 or jpeg_quality > 100:
+        raise ValueError("JPEG quality must stay between 70 and 100.")
+    normalized = {
+        "default_scale": str(scale),
+        "default_variant": variant,
+        "default_alpha": f"{alpha:.2f}",
+        "default_tile_mode": str(tile_mode),
+        "default_cache_mode": str(cache_mode),
+        "max_input_long_edge": str(max_edge),
+        "max_input_pixels": str(max_pixels),
+        "jpeg_quality": str(jpeg_quality),
+    }
+    if variant not in MODEL_CATALOG.get(scale, {}):
+        raise ValueError("Default model pair is not supported.")
+    return normalized
+
+
+def get_flash(request: Request) -> dict[str, str] | None:
+    flash = request.session.pop("flash", None)
+    return flash
+
+
+def set_flash(request: Request, level: str, message: str) -> None:
+    request.session["flash"] = {"level": level, "message": message}
+
+
+def csrf_token(request: Request) -> str:
+    token = request.session.get("csrf_token")
+    if not token:
+        token = generate_csrf_token()
+        request.session["csrf_token"] = token
+    return token
+
+
+def ensure_csrf(request: Request, token: str) -> None:
+    stored = request.session.get("csrf_token")
+    if not stored or token != stored:
+        raise HTTPException(status_code=400, detail="CSRF token mismatch.")
+
+
+def extract_api_key(request: Request) -> str:
+    authorization = request.headers.get("authorization", "")
+    if authorization.lower().startswith("bearer "):
+        return authorization.split(" ", 1)[1].strip()
+    return request.headers.get("x-api-key", "").strip()
+
+
+def authenticate_api_request(request: Request) -> dict[str, Any]:
+    secret = extract_api_key(request)
+    if not secret:
+        raise HTTPException(status_code=401, detail="Missing API key.")
+    row = db.find_api_key_by_prefix(key_prefix(secret))
+    if row is None or not row["enabled"]:
+        raise HTTPException(status_code=401, detail="Invalid API key.")
+    if not verify_secret(secret, row["secret_hash"]):
+        raise HTTPException(status_code=401, detail="Invalid API key.")
+    db.touch_api_key(int(row["id"]))
+    return dict(row)
+
+
+def dashboard_context(request: Request, *, issued_key: str | None = None) -> dict[str, Any]:
+    settings = get_runtime_settings()
+    metrics = db.dashboard_metrics()
+    jobs = [dict(row) for row in db.list_recent_jobs(30)]
+    model_rows = runtime.available_models()
+    daily_counts = db.daily_job_counts(7)
+    grouped_models: dict[int, list[dict[str, Any]]] = {}
+    for row in model_rows:
+        grouped_models.setdefault(row["scale"], []).append(row)
+    max_daily_count = max((item["count"] for item in daily_counts), default=1)
+    return {
+        "request": request,
+        "app_name": env.app_name,
+        "flash": get_flash(request),
+        "user": get_current_user(request),
+        "csrf_token": csrf_token(request),
+        "settings": settings,
+        "settings_spec": RUNTIME_FIELD_SPECS,
+        "metrics": metrics,
+        "daily_counts": daily_counts,
+        "max_daily_count": max_daily_count,
+        "jobs": jobs,
+        "api_keys": [dict(row) for row in db.list_api_keys()],
+        "runtime_status": runtime.runtime_status(),
+        "models_by_scale": grouped_models,
+        "issued_key": issued_key or request.session.pop("issued_api_key", None),
+        "admin_configured": bool(db.get_user_by_username(env.admin_username)),
+        "server_time": now_local_text(),
+        "space_hint": {
+            "cpu_tier": "CPU Basic",
+            "cpu_spec": "2 vCPU / 16 GB RAM",
+        },
+    }
+
+
+@app.get("/", response_class=JSONResponse)
+async def root() -> JSONResponse:
+    return JSONResponse(
+        {
+            "name": env.app_name,
+            "admin": "/admin",
+            "health": "/healthz",
+            "api": "/api/v1/upscale",
+        }
+    )
+
+
+@app.get("/healthz", response_class=JSONResponse)
+async def healthz() -> JSONResponse:
+    return JSONResponse(
+        {
+            "status": "ok",
+            "busy": runtime.busy,
+            "models_loaded": runtime.runtime_status()["loaded_models"],
+            "admin_configured": bool(db.get_user_by_username(env.admin_username)),
+        }
+    )
+
+
+@app.get("/admin/login", response_class=HTMLResponse)
+async def admin_login_page(request: Request) -> HTMLResponse:
+    if get_current_user(request):
+        return RedirectResponse("/admin", status_code=303)
+    return templates.TemplateResponse(
+        request,
+        "login.html",
+        {
+            "app_name": env.app_name,
+            "flash": get_flash(request),
+            "csrf_token": csrf_token(request),
+            "admin_username": env.admin_username,
+            "admin_configured": bool(db.get_user_by_username(env.admin_username)),
+        },
+    )
+
+
+@app.post("/admin/bootstrap")
+async def admin_bootstrap(
+    request: Request,
+    password: str = Form(...),
+    confirm_password: str = Form(...),
+    csrf: str = Form(...),
+) -> RedirectResponse:
+    ensure_csrf(request, csrf)
+    if db.get_user_by_username(env.admin_username) is not None:
+        set_flash(request, "error", "Admin account already exists.")
+        return RedirectResponse("/admin/login", status_code=303)
+    if len(password) < 10:
+        set_flash(request, "error", "Admin password must be at least 10 characters.")
+        return RedirectResponse("/admin/login", status_code=303)
+    if password != confirm_password:
+        set_flash(request, "error", "Password confirmation does not match.")
+        return RedirectResponse("/admin/login", status_code=303)
+    db.ensure_admin_user(env.admin_username, hash_secret(password))
+    user = db.get_user_by_username(env.admin_username)
+    request.session["user_id"] = int(user["id"])
+    set_flash(request, "success", "Admin account initialized.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/login")
+async def admin_login(
+    request: Request,
+    username: str = Form(...),
+    password: str = Form(...),
+    csrf: str = Form(...),
+) -> RedirectResponse:
+    ensure_csrf(request, csrf)
+    row = db.get_user_by_username(username)
+    if row is None or not verify_secret(password, row["password_hash"]):
+        set_flash(request, "error", "Login failed. Check username and password.")
+        return RedirectResponse("/admin/login", status_code=303)
+    request.session["user_id"] = int(row["id"])
+    set_flash(request, "success", "Signed in.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/logout")
+async def admin_logout(request: Request, csrf: str = Form(...)) -> RedirectResponse:
+    ensure_csrf(request, csrf)
+    request.session.clear()
+    set_flash(request, "success", "Signed out.")
+    return RedirectResponse("/admin/login", status_code=303)
+
+
+@app.get("/admin", response_class=HTMLResponse)
+async def admin_dashboard(request: Request) -> HTMLResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    return templates.TemplateResponse(request, "dashboard.html", dashboard_context(request))
+
+
+@app.post("/admin/settings")
+async def update_settings(request: Request) -> RedirectResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    form = await request.form()
+    ensure_csrf(request, str(form.get("csrf", "")))
+    payload = {field["name"]: str(form.get(field["name"], "")).strip() for field in RUNTIME_FIELD_SPECS}
+    try:
+        normalized = validate_settings_payload(payload)
+    except ValueError as exc:
+        set_flash(request, "error", str(exc))
+        return RedirectResponse("/admin", status_code=303)
+    db.set_settings(normalized)
+    set_flash(request, "success", "Runtime settings updated.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/password")
+async def update_password(request: Request) -> RedirectResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    form = await request.form()
+    ensure_csrf(request, str(form.get("csrf", "")))
+    current = str(form.get("current_password", ""))
+    new_password = str(form.get("new_password", ""))
+    confirm = str(form.get("confirm_password", ""))
+    user = db.get_user_by_username(env.admin_username)
+    if user is None or not verify_secret(current, user["password_hash"]):
+        set_flash(request, "error", "Current password is incorrect.")
+        return RedirectResponse("/admin", status_code=303)
+    if len(new_password) < 10:
+        set_flash(request, "error", "New password must be at least 10 characters.")
+        return RedirectResponse("/admin", status_code=303)
+    if new_password != confirm:
+        set_flash(request, "error", "New password confirmation does not match.")
+        return RedirectResponse("/admin", status_code=303)
+    db.update_admin_password(env.admin_username, hash_secret(new_password))
+    set_flash(request, "success", "Admin password updated.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/api-keys")
+async def create_api_key_admin(request: Request) -> RedirectResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    form = await request.form()
+    ensure_csrf(request, str(form.get("csrf", "")))
+    name = str(form.get("name", "")).strip()
+    if len(name) < 2:
+        set_flash(request, "error", "API key name must be at least 2 characters.")
+        return RedirectResponse("/admin", status_code=303)
+    secret = generate_api_key()
+    db.create_api_key(name, key_prefix(secret), hash_secret(secret))
+    request.session["issued_api_key"] = secret
+    set_flash(request, "success", "New API key created. Copy it now, it will not be shown again.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/api-keys/{key_id}/toggle")
+async def toggle_api_key(key_id: int, request: Request) -> RedirectResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    form = await request.form()
+    ensure_csrf(request, str(form.get("csrf", "")))
+    enabled = str(form.get("enabled", "0")) == "1"
+    db.set_api_key_enabled(key_id, enabled)
+    set_flash(request, "success", "API key status updated.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.post("/admin/api-keys/{key_id}/delete")
+async def delete_api_key(key_id: int, request: Request) -> RedirectResponse:
+    if get_current_user(request) is None:
+        return redirect_to_login()
+    form = await request.form()
+    ensure_csrf(request, str(form.get("csrf", "")))
+    db.delete_api_key(key_id)
+    set_flash(request, "success", "API key deleted.")
+    return RedirectResponse("/admin", status_code=303)
+
+
+@app.get("/admin/metrics", response_class=JSONResponse)
+async def admin_metrics(request: Request) -> JSONResponse:
+    if get_current_user(request) is None:
+        return JSONResponse({"detail": "Admin login required."}, status_code=401)
+    payload = {
+        "summary": db.dashboard_metrics(),
+        "daily_counts": db.daily_job_counts(14),
+        "runtime": runtime.runtime_status(),
+        "settings": get_runtime_settings(),
+    }
+    return JSONResponse(payload)
+
+
+@app.post("/api/v1/upscale")
+async def upscale_image(
+    request: Request,
+    file: UploadFile | None = File(None),
+    scale: int | None = Form(None),
+    variant: str | None = Form(None),
+    alpha: float | None = Form(None),
+    tile_mode: int | None = Form(None),
+    cache_mode: int | None = Form(None),
+    response_format: str = Form("png"),
+) -> Response:
+    authenticate_api_request(request)
+    if file is None:
+        raise HTTPException(status_code=400, detail="Missing image file.")
+    settings = typed_runtime_settings()
+    chosen_scale = scale or settings["default_scale"]
+    chosen_variant = variant or settings["default_variant"]
+    chosen_alpha = alpha if alpha is not None else settings["default_alpha"]
+    chosen_tile = tile_mode if tile_mode is not None else settings["default_tile_mode"]
+    chosen_cache = cache_mode if cache_mode is not None else settings["default_cache_mode"]
+    chosen_format = response_format.strip().lower()
+    if chosen_format not in {"png", "jpeg", "webp"}:
+        raise HTTPException(status_code=400, detail="Unsupported response_format.")
+    payload = await file.read()
+    if not payload:
+        raise HTTPException(status_code=400, detail="Empty upload.")
+    try:
+        prepared = runtime.inspect_input(
+            payload,
+            max_input_long_edge=settings["max_input_long_edge"],
+            max_input_pixels=settings["max_input_pixels"],
+        )
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc)) from exc
+    job_id = db.create_job(
+        status="queued",
+        source_filename=file.filename or "upload",
+        input_sha256=prepared.input_sha256,
+        input_width=prepared.width,
+        input_height=prepared.height,
+        scale=chosen_scale,
+        model_variant=chosen_variant,
+        alpha=chosen_alpha,
+        tile_mode_requested=chosen_tile,
+        cache_mode=chosen_cache,
+        response_format=chosen_format,
+    )
+    db.mark_job_running(job_id)
+    try:
+        result = runtime.upscale(
+            prepared,
+            scale=chosen_scale,
+            variant=chosen_variant,
+            alpha=chosen_alpha,
+            tile_mode=chosen_tile,
+            cache_mode=chosen_cache,
+            response_format=chosen_format,
+            jpeg_quality=settings["jpeg_quality"],
+        )
+    except BusyError as exc:
+        db.mark_job_failed(job_id, str(exc))
+        raise HTTPException(status_code=429, detail=str(exc)) from exc
+    except (RuntimeConfigurationError, UnsupportedModelError) as exc:
+        db.mark_job_failed(job_id, str(exc))
+        raise HTTPException(status_code=503, detail=str(exc)) from exc
+    except Exception as exc:  # noqa: BLE001
+        db.mark_job_failed(job_id, str(exc))
+        raise HTTPException(status_code=500, detail="Upscaling failed.") from exc
+    db.mark_job_success(
+        job_id,
+        output_width=result.output_width,
+        output_height=result.output_height,
+        tile_mode_used=result.tile_mode_used,
+        duration_ms=result.duration_ms,
+    )
+    headers = {
+        "X-Job-Id": str(job_id),
+        "X-Scale": str(result.scale),
+        "X-Variant": result.variant,
+        "X-Tile-Mode-Used": str(result.tile_mode_used),
+        "X-Cache-Mode-Used": str(result.cache_mode_used),
+        "X-Duration-Ms": str(result.duration_ms),
+    }
+    return Response(content=result.content, media_type=result.media_type, headers=headers)

app/runtime.py

@@ -0,0 +1,366 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+import hashlib
+import importlib.util
+import io
+import threading
+import time
+from pathlib import Path
+from types import ModuleType
+from typing import Any
+
+import numpy as np
+from PIL import Image
+import requests
+
+from .config import EnvSettings, MODEL_CATALOG
+
+
+class RuntimeConfigurationError(RuntimeError):
+    """Raised when Real-CUGAN runtime cannot be prepared."""
+
+
+class UnsupportedModelError(RuntimeError):
+    """Raised when a scale or variant pair has no supported weight."""
+
+
+class BusyError(RuntimeError):
+    """Raised when another inference is already running."""
+
+
+@dataclass(slots=True)
+class PreparedImage:
+    input_sha256: str
+    rgb: np.ndarray
+    alpha: Image.Image | None
+    width: int
+    height: int
+
+
+@dataclass(slots=True)
+class UpscaleResult:
+    content: bytes
+    media_type: str
+    output_width: int
+    output_height: int
+    tile_mode_used: int
+    cache_mode_used: int
+    duration_ms: int
+    scale: int
+    variant: str
+
+
+class RealCuganRuntime:
+    def __init__(self, env: EnvSettings) -> None:
+        self.env = env
+        self._lock = threading.Lock()
+        self._module: ModuleType | None = None
+        self._models: dict[tuple[int, str], Any] = {}
+        self._last_runtime_error: str | None = None
+
+    @property
+    def busy(self) -> bool:
+        return self._lock.locked()
+
+    @property
+    def last_runtime_error(self) -> str | None:
+        return self._last_runtime_error
+
+    def inspect_input(
+        self,
+        payload: bytes,
+        *,
+        max_input_long_edge: int,
+        max_input_pixels: int,
+    ) -> PreparedImage:
+        digest = hashlib.sha256(payload).hexdigest()
+        try:
+            with Image.open(io.BytesIO(payload)) as image:
+                image.load()
+                width, height = image.size
+                if width < 8 or height < 8:
+                    raise ValueError("Image is too small. Minimum dimension is 8px.")
+                if max(width, height) > max_input_long_edge:
+                    raise ValueError(
+                        f"Image too large. Long edge {max(width, height)} exceeds limit {max_input_long_edge}."
+                    )
+                if width * height > max_input_pixels:
+                    raise ValueError(
+                        f"Image too large. Pixel count {width * height} exceeds limit {max_input_pixels}."
+                    )
+                rgba = image.convert("RGBA")
+                alpha = rgba.getchannel("A") if "A" in rgba.getbands() else None
+                rgb = np.asarray(rgba.convert("RGB"), dtype=np.uint8)
+        except OSError as exc:
+            raise ValueError("Unsupported or corrupted image file.") from exc
+        return PreparedImage(
+            input_sha256=digest,
+            rgb=rgb,
+            alpha=alpha,
+            width=width,
+            height=height,
+        )
+
+    def available_models(self) -> list[dict[str, Any]]:
+        rows: list[dict[str, Any]] = []
+        for scale, variants in MODEL_CATALOG.items():
+            for variant, candidates in variants.items():
+                resolved = next((name for name in candidates if (self.env.weights_dir / name).exists()), None)
+                rows.append(
+                    {
+                        "scale": scale,
+                        "variant": variant,
+                        "filename": resolved or candidates[0],
+                        "present": bool(resolved),
+                        "downloadable": bool(self.env.real_cugan_weight_base_url),
+                    }
+                )
+        return rows
+
+    def runtime_status(self) -> dict[str, Any]:
+        vendor_path = self.env.vendor_dir / "upcunet_v3.py"
+        return {
+            "busy": self.busy,
+            "loaded_models": sorted(f"{scale}x/{variant}" for scale, variant in self._models),
+            "vendor_ready": vendor_path.exists(),
+            "vendor_path": str(vendor_path),
+            "last_runtime_error": self._last_runtime_error,
+        }
+
+    def upscale(
+        self,
+        prepared: PreparedImage,
+        *,
+        scale: int,
+        variant: str,
+        alpha: float,
+        tile_mode: int,
+        cache_mode: int,
+        response_format: str,
+        jpeg_quality: int,
+    ) -> UpscaleResult:
+        if not self._lock.acquire(blocking=False):
+            raise BusyError("Another inference is already running.")
+        started = time.perf_counter()
+        try:
+            model = self._load_model(scale, variant)
+            tile_candidates = self._candidate_tile_modes(tile_mode)
+            cache_candidates = self._candidate_cache_modes(cache_mode)
+            last_exc: Exception | None = None
+            used_tile = tile_mode
+            used_cache = cache_mode
+            for cache_candidate in cache_candidates:
+                for tile_candidate in tile_candidates:
+                    try:
+                        output = model(
+                            prepared.rgb,
+                            tile_mode=tile_candidate,
+                            cache_mode=cache_candidate,
+                            alpha=alpha,
+                        )
+                        used_tile = tile_candidate
+                        used_cache = cache_candidate
+                        return self._serialize_output(
+                            prepared=prepared,
+                            output=output,
+                            response_format=response_format,
+                            jpeg_quality=jpeg_quality,
+                            scale=scale,
+                            variant=variant,
+                            tile_mode_used=used_tile,
+                            cache_mode_used=used_cache,
+                            started=started,
+                        )
+                    except Exception as exc:  # noqa: BLE001
+                        last_exc = exc
+                        if not self._should_retry(exc):
+                            raise
+                        continue
+            if last_exc:
+                raise last_exc
+            raise RuntimeConfigurationError("Inference failed before execution.")
+        except Exception as exc:  # noqa: BLE001
+            self._last_runtime_error = str(exc)
+            raise
+        finally:
+            self._lock.release()
+
+    def _serialize_output(
+        self,
+        *,
+        prepared: PreparedImage,
+        output: np.ndarray,
+        response_format: str,
+        jpeg_quality: int,
+        scale: int,
+        variant: str,
+        tile_mode_used: int,
+        cache_mode_used: int,
+        started: float,
+    ) -> UpscaleResult:
+        image = Image.fromarray(output.astype(np.uint8), mode="RGB")
+        if prepared.alpha is not None and response_format in {"png", "webp"}:
+            alpha = prepared.alpha.resize(image.size, Image.Resampling.LANCZOS)
+            image = image.convert("RGBA")
+            image.putalpha(alpha)
+        if response_format == "jpeg":
+            image = image.convert("RGB")
+        buffer = io.BytesIO()
+        save_kwargs: dict[str, Any] = {}
+        if response_format == "jpeg":
+            save_kwargs["quality"] = jpeg_quality
+            save_kwargs["optimize"] = True
+        if response_format == "webp":
+            save_kwargs["quality"] = jpeg_quality
+            save_kwargs["method"] = 6
+        image.save(buffer, format=response_format.upper(), **save_kwargs)
+        duration_ms = int((time.perf_counter() - started) * 1000)
+        media_type = {
+            "png": "image/png",
+            "jpeg": "image/jpeg",
+            "webp": "image/webp",
+        }[response_format]
+        return UpscaleResult(
+            content=buffer.getvalue(),
+            media_type=media_type,
+            output_width=image.width,
+            output_height=image.height,
+            tile_mode_used=tile_mode_used,
+            cache_mode_used=cache_mode_used,
+            duration_ms=duration_ms,
+            scale=scale,
+            variant=variant,
+        )
+
+    def _load_model(self, scale: int, variant: str) -> Any:
+        if scale not in MODEL_CATALOG or variant not in MODEL_CATALOG[scale]:
+            raise UnsupportedModelError(f"Unsupported model selection: {scale}x / {variant}")
+        key = (scale, variant)
+        cached = self._models.get(key)
+        if cached is not None:
+            return cached
+        module = self._load_vendor_module()
+        weight_path = self._resolve_weight_path(scale, variant)
+        try:
+            model = module.RealWaifuUpScaler(scale, str(weight_path), half=False, device="cpu")
+        except ModuleNotFoundError as exc:
+            raise RuntimeConfigurationError(
+                "PyTorch is not installed in the current environment."
+            ) from exc
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeConfigurationError(f"Failed to load weight {weight_path.name}: {exc}") from exc
+        self._models[key] = model
+        return model
+
+    def _load_vendor_module(self) -> ModuleType:
+        if self._module is not None:
+            return self._module
+        vendor_path = self._ensure_vendor_file()
+        spec = importlib.util.spec_from_file_location("real_cugan_vendor", vendor_path)
+        if spec is None or spec.loader is None:
+            raise RuntimeConfigurationError("Failed to prepare Real-CUGAN vendor module loader.")
+        module = importlib.util.module_from_spec(spec)
+        try:
+            spec.loader.exec_module(module)
+        except ModuleNotFoundError as exc:
+            raise RuntimeConfigurationError(
+                "Real-CUGAN runtime import failed. PyTorch is not installed in the current environment."
+            ) from exc
+        except Exception as exc:  # noqa: BLE001
+            raise RuntimeConfigurationError(f"Real-CUGAN vendor import failed: {exc}") from exc
+        self._module = module
+        return module
+
+    def _ensure_vendor_file(self) -> Path:
+        vendor_path = self.env.vendor_dir / "upcunet_v3.py"
+        if vendor_path.exists() and self._sha256(vendor_path) == self.env.real_cugan_sha256:
+            return vendor_path
+        try:
+            response = requests.get(self.env.real_cugan_upstream_url, timeout=45)
+        except requests.RequestException as exc:
+            raise RuntimeConfigurationError(
+                f"Failed to download Real-CUGAN upstream file: {exc}"
+            ) from exc
+        if response.status_code != 200:
+            raise RuntimeConfigurationError(
+                f"Failed to download Real-CUGAN upstream file, status {response.status_code}."
+            )
+        payload = response.content
+        digest = hashlib.sha256(payload).hexdigest()
+        if digest != self.env.real_cugan_sha256:
+            raise RuntimeConfigurationError(
+                "Real-CUGAN upstream checksum mismatch. Refusing to execute unverified code."
+            )
+        vendor_path.write_bytes(payload)
+        return vendor_path
+
+    def _resolve_weight_path(self, scale: int, variant: str) -> Path:
+        candidates = MODEL_CATALOG[scale][variant]
+        for filename in candidates:
+            path = self.env.weights_dir / filename
+            if path.exists():
+                return path
+        if self.env.real_cugan_weight_base_url:
+            for filename in candidates:
+                downloaded = self._download_weight(filename)
+                if downloaded is not None:
+                    return downloaded
+        raise RuntimeConfigurationError(
+            f"Weight for {scale}x / {variant} not found in {self.env.weights_dir}."
+        )
+
+    def _download_weight(self, filename: str) -> Path | None:
+        url = f"{self.env.real_cugan_weight_base_url}/{filename}"
+        try:
+            response = requests.get(url, timeout=120, stream=True)
+        except requests.RequestException:
+            return None
+        if response.status_code != 200:
+            return None
+        tmp_path = self.env.weights_dir / f".{filename}.part"
+        final_path = self.env.weights_dir / filename
+        with tmp_path.open("wb") as handle:
+            for chunk in response.iter_content(chunk_size=1024 * 1024):
+                if chunk:
+                    handle.write(chunk)
+        tmp_path.replace(final_path)
+        return final_path
+
+    @staticmethod
+    def _sha256(path: Path) -> str:
+        digest = hashlib.sha256()
+        with path.open("rb") as handle:
+            for chunk in iter(lambda: handle.read(1024 * 1024), b""):
+                digest.update(chunk)
+        return digest.hexdigest()
+
+    @staticmethod
+    def _candidate_tile_modes(tile_mode: int) -> list[int]:
+        ordered: list[int] = []
+        for value in [tile_mode, 5, 4, 3, 2, 1, 0]:
+            if value not in ordered:
+                ordered.append(value)
+        return ordered
+
+    @staticmethod
+    def _candidate_cache_modes(cache_mode: int) -> list[int]:
+        ordered: list[int] = []
+        for value in [cache_mode, 1, 0]:
+            if value not in ordered:
+                ordered.append(value)
+        return ordered
+
+    @staticmethod
+    def _should_retry(exc: Exception) -> bool:
+        if isinstance(exc, MemoryError):
+            return True
+        message = str(exc).lower()
+        retry_signals = [
+            "out of memory",
+            "can't allocate",
+            "cannot allocate",
+            "std::bad_alloc",
+            "not enough memory",
+        ]
+        return any(signal in message for signal in retry_signals)

app/security.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+import base64
+import hashlib
+import hmac
+import secrets
+
+
+PBKDF2_ROUNDS = 210_000
+
+
+def _b64(data: bytes) -> str:
+    return base64.urlsafe_b64encode(data).decode("ascii").rstrip("=")
+
+
+def _unb64(value: str) -> bytes:
+    padding = "=" * (-len(value) % 4)
+    return base64.urlsafe_b64decode(value + padding)
+
+
+def hash_secret(secret: str) -> str:
+    salt = secrets.token_bytes(16)
+    digest = hashlib.pbkdf2_hmac("sha256", secret.encode("utf-8"), salt, PBKDF2_ROUNDS)
+    return f"pbkdf2_sha256${PBKDF2_ROUNDS}${_b64(salt)}${_b64(digest)}"
+
+
+def verify_secret(secret: str, stored_hash: str) -> bool:
+    try:
+        algorithm, rounds_text, salt_text, digest_text = stored_hash.split("$", 3)
+        if algorithm != "pbkdf2_sha256":
+            return False
+        rounds = int(rounds_text)
+        salt = _unb64(salt_text)
+        expected = _unb64(digest_text)
+    except (ValueError, TypeError):
+        return False
+    actual = hashlib.pbkdf2_hmac("sha256", secret.encode("utf-8"), salt, rounds)
+    return hmac.compare_digest(actual, expected)
+
+
+def generate_api_key() -> str:
+    return "rcg_" + secrets.token_urlsafe(32)
+
+
+def key_prefix(secret: str) -> str:
+    return secret[:12]
+
+
+def generate_csrf_token() -> str:
+    return secrets.token_urlsafe(24)

app/static/dashboard.js

@@ -0,0 +1,48 @@
+const shell = document.querySelector(".console-shell");
+
+async function refreshMetrics() {
+  if (!shell) return;
+  const url = shell.dataset.metricsUrl;
+  if (!url) return;
+  try {
+    const response = await fetch(url, {
+      headers: {
+        "X-Requested-With": "dashboard",
+      },
+      credentials: "same-origin",
+    });
+    if (!response.ok) return;
+    const payload = await response.json();
+    for (const [name, value] of Object.entries(payload.summary || {})) {
+      const node = document.querySelector(`[data-metric="${name}"]`);
+      if (!node) continue;
+      node.textContent = name === "avg_duration_ms" ? `${value} ms` : String(value);
+    }
+  } catch (_) {
+    // Keep the dashboard quiet during background refresh failures.
+  }
+}
+
+function bindCopyButtons() {
+  document.querySelectorAll("[data-copy-target]").forEach((button) => {
+    button.addEventListener("click", async () => {
+      const targetId = button.getAttribute("data-copy-target");
+      const target = targetId ? document.getElementById(targetId) : null;
+      if (!target) return;
+      const text = target.textContent || "";
+      try {
+        await navigator.clipboard.writeText(text);
+        button.textContent = "Copied";
+        setTimeout(() => {
+          button.textContent = "Copy key";
+        }, 1400);
+      } catch (_) {
+        button.textContent = "Copy failed";
+      }
+    });
+  });
+}
+
+bindCopyButtons();
+refreshMetrics();
+setInterval(refreshMetrics, 15000);

app/static/styles.css

@@ -0,0 +1,663 @@
+:root {
+  color-scheme: light;
+  --bg: oklch(0.965 0.012 95);
+  --panel: oklch(0.99 0.004 95);
+  --panel-strong: oklch(0.973 0.008 95);
+  --line: oklch(0.885 0.016 88);
+  --line-strong: oklch(0.79 0.03 86);
+  --text: oklch(0.25 0.02 92);
+  --muted: oklch(0.48 0.018 90);
+  --accent: oklch(0.66 0.13 75);
+  --accent-soft: oklch(0.9 0.04 79);
+  --green: oklch(0.62 0.13 150);
+  --green-soft: oklch(0.91 0.03 150);
+  --red: oklch(0.6 0.17 26);
+  --red-soft: oklch(0.92 0.03 28);
+  --amber: oklch(0.72 0.15 80);
+  --amber-soft: oklch(0.93 0.03 83);
+  --shadow: 0 18px 38px rgba(67, 48, 21, 0.08);
+  --radius: 18px;
+  --radius-sm: 12px;
+  --content-width: 1420px;
+  --mono: "JetBrains Mono", "SFMono-Regular", Consolas, monospace;
+  --sans: "Public Sans", "Segoe UI", sans-serif;
+}
+
+* {
+  box-sizing: border-box;
+}
+
+html {
+  background: var(--bg);
+  color: var(--text);
+  font-family: var(--sans);
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+body {
+  margin: 0;
+  min-height: 100vh;
+  background:
+    radial-gradient(circle at top right, rgba(215, 175, 81, 0.12), transparent 28%),
+    radial-gradient(circle at left 20% bottom 10%, rgba(109, 169, 121, 0.09), transparent 30%),
+    linear-gradient(180deg, rgba(255, 255, 255, 0.78), rgba(246, 241, 233, 0.92));
+  color: var(--text);
+}
+
+button,
+input,
+select,
+textarea {
+  font: inherit;
+}
+
+code,
+pre,
+.mono {
+  font-family: var(--mono);
+  font-variant-numeric: tabular-nums;
+}
+
+.eyebrow {
+  margin: 0 0 0.55rem;
+  color: var(--muted);
+  font-size: 0.78rem;
+  font-weight: 700;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+}
+
+.console-shell,
+.auth-layout {
+  width: min(calc(100% - 32px), var(--content-width));
+  margin: 0 auto;
+}
+
+.auth-shell {
+  display: grid;
+  place-items: center;
+  padding: 28px 0;
+}
+
+.auth-layout {
+  display: grid;
+  grid-template-columns: 1.2fr 0.9fr;
+  gap: 20px;
+  align-items: stretch;
+}
+
+.auth-panel,
+.panel,
+.summary-card,
+.banner {
+  border: 1px solid rgba(121, 93, 48, 0.12);
+  background: linear-gradient(180deg, rgba(255, 255, 255, 0.94), rgba(250, 246, 239, 0.96));
+  border-radius: var(--radius);
+  box-shadow: var(--shadow);
+}
+
+.auth-panel {
+  padding: 28px;
+}
+
+.auth-panel--hero {
+  position: relative;
+  overflow: hidden;
+}
+
+.auth-panel--hero::after {
+  content: "";
+  position: absolute;
+  right: -50px;
+  top: -80px;
+  width: 240px;
+  height: 240px;
+  border-radius: 50%;
+  background: radial-gradient(circle, rgba(213, 168, 62, 0.24), rgba(213, 168, 62, 0));
+  pointer-events: none;
+}
+
+.auth-panel h1,
+.topbar h1 {
+  margin: 0;
+  max-width: 12ch;
+  font-size: clamp(2.1rem, 4.2vw, 4rem);
+  line-height: 0.95;
+  letter-spacing: -0.045em;
+  text-wrap: balance;
+}
+
+.auth-copy,
+.topbar-copy,
+.panel-note,
+.auth-panel p,
+.summary-card p,
+.runtime-list dd,
+.empty-state {
+  color: var(--muted);
+  text-wrap: pretty;
+}
+
+.auth-grid {
+  display: grid;
+  gap: 14px;
+  margin-top: 24px;
+}
+
+.auth-grid article {
+  padding: 16px 18px;
+  border-radius: var(--radius-sm);
+  background: rgba(255, 251, 244, 0.72);
+  border: 1px solid rgba(125, 95, 46, 0.1);
+}
+
+.auth-grid strong,
+.summary-card strong {
+  display: block;
+  margin: 6px 0;
+  font-size: 1.2rem;
+}
+
+.metric-label {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.panel-heading {
+  display: flex;
+  justify-content: space-between;
+  gap: 16px;
+  align-items: flex-start;
+  margin-bottom: 18px;
+}
+
+.panel-heading h2 {
+  margin: 0;
+  font-size: 1.3rem;
+  line-height: 1;
+  letter-spacing: -0.03em;
+}
+
+.stack-form,
+.settings-grid,
+.inline-form {
+  display: grid;
+  gap: 14px;
+}
+
+.settings-grid {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+}
+
+.field,
+.stack-form label {
+  display: grid;
+  gap: 8px;
+}
+
+.field span,
+.stack-form span {
+  font-weight: 700;
+}
+
+input,
+select,
+textarea {
+  width: 100%;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  background: rgba(255, 255, 255, 0.88);
+  padding: 0.86rem 0.95rem;
+  color: var(--text);
+  transition-property: border-color, box-shadow, background-color;
+  transition-duration: 160ms;
+  transition-timing-function: cubic-bezier(0.2, 0, 0, 1);
+}
+
+input:focus-visible,
+select:focus-visible,
+textarea:focus-visible,
+button:focus-visible {
+  outline: none;
+  border-color: rgba(190, 140, 33, 0.65);
+  box-shadow: 0 0 0 4px rgba(204, 156, 46, 0.12);
+}
+
+input:disabled {
+  background: rgba(245, 238, 227, 0.92);
+  color: var(--muted);
+}
+
+.field small {
+  color: var(--muted);
+  font-size: 0.88rem;
+  line-height: 1.45;
+}
+
+.button {
+  display: inline-flex;
+  align-items: center;
+  justify-content: center;
+  gap: 8px;
+  min-height: 44px;
+  padding: 0 16px;
+  border: 1px solid transparent;
+  border-radius: 999px;
+  cursor: pointer;
+  font-weight: 700;
+  transition-property: transform, background-color, border-color, color, opacity;
+  transition-duration: 160ms;
+  transition-timing-function: cubic-bezier(0.2, 0, 0, 1);
+  touch-action: manipulation;
+}
+
+.button:active {
+  transform: scale(0.97);
+}
+
+.button--primary {
+  background: linear-gradient(180deg, rgba(211, 161, 45, 0.95), rgba(178, 125, 21, 0.98));
+  color: white;
+}
+
+.button--secondary {
+  background: rgba(223, 189, 118, 0.16);
+  border-color: rgba(183, 140, 41, 0.2);
+  color: var(--text);
+}
+
+.button--ghost {
+  background: rgba(255, 255, 255, 0.7);
+  border-color: rgba(125, 95, 46, 0.16);
+  color: var(--text);
+}
+
+.button--danger {
+  background: rgba(188, 74, 54, 0.08);
+  border-color: rgba(188, 74, 54, 0.18);
+  color: oklch(0.42 0.14 23);
+}
+
+.flash {
+  margin: 0 0 16px;
+  padding: 14px 16px;
+  border-radius: 14px;
+  font-weight: 600;
+}
+
+.flash--success {
+  background: var(--green-soft);
+  color: oklch(0.33 0.08 150);
+}
+
+.flash--error {
+  background: var(--red-soft);
+  color: oklch(0.4 0.12 24);
+}
+
+.topbar {
+  display: flex;
+  justify-content: space-between;
+  gap: 20px;
+  align-items: flex-start;
+  padding: 28px 0 18px;
+}
+
+.topbar-actions {
+  display: flex;
+  align-items: center;
+  gap: 12px;
+}
+
+.status-chip,
+.status-pill,
+.inventory-state {
+  display: inline-flex;
+  align-items: center;
+  gap: 8px;
+  border-radius: 999px;
+  padding: 0.45rem 0.8rem;
+  font-size: 0.84rem;
+  font-weight: 700;
+}
+
+.status-chip {
+  background: rgba(255, 255, 255, 0.8);
+  border: 1px solid rgba(125, 95, 46, 0.12);
+}
+
+.status-chip--ok,
+.inventory-state--ok,
+.status-pill--succeeded {
+  color: oklch(0.35 0.09 150);
+  background: var(--green-soft);
+}
+
+.status-chip--warn,
+.status-pill--running,
+.status-pill--queued {
+  color: oklch(0.43 0.1 80);
+  background: var(--amber-soft);
+}
+
+.status-pill--failed,
+.inventory-state--miss {
+  color: oklch(0.42 0.13 24);
+  background: var(--red-soft);
+}
+
+.status-dot {
+  width: 8px;
+  height: 8px;
+  border-radius: 999px;
+  background: currentColor;
+}
+
+.banner {
+  display: flex;
+  justify-content: space-between;
+  gap: 18px;
+  align-items: center;
+  padding: 18px 20px;
+  margin-bottom: 18px;
+  background: linear-gradient(135deg, rgba(255, 246, 220, 0.98), rgba(246, 254, 243, 0.98));
+}
+
+.banner h2 {
+  margin: 0;
+  font-size: 1.15rem;
+}
+
+.key-display {
+  display: grid;
+  gap: 10px;
+  justify-items: end;
+}
+
+.key-display code {
+  display: inline-block;
+  max-width: min(100%, 520px);
+  overflow-wrap: anywhere;
+  padding: 12px 14px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.78);
+}
+
+.summary-grid,
+.main-grid,
+.control-grid {
+  display: grid;
+  gap: 18px;
+}
+
+.summary-grid {
+  grid-template-columns: repeat(4, minmax(0, 1fr));
+}
+
+.summary-card,
+.panel {
+  padding: 20px;
+}
+
+.summary-card strong {
+  font-size: clamp(1.7rem, 2vw, 2.4rem);
+  letter-spacing: -0.04em;
+}
+
+.main-grid {
+  grid-template-columns: minmax(0, 1.7fr) minmax(320px, 0.9fr);
+  margin-top: 18px;
+}
+
+.control-grid {
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  margin: 18px 0 32px;
+}
+
+.bar-strip {
+  display: grid;
+  grid-template-columns: repeat(7, minmax(0, 1fr));
+  gap: 12px;
+  min-height: 180px;
+  align-items: end;
+}
+
+.bar-item {
+  display: grid;
+  justify-items: center;
+  gap: 8px;
+}
+
+.bar-track {
+  position: relative;
+  width: 100%;
+  min-height: 140px;
+  border-radius: 16px;
+  background: linear-gradient(180deg, rgba(239, 230, 207, 0.5), rgba(255, 255, 255, 0.85));
+  border: 1px solid rgba(126, 96, 47, 0.08);
+  overflow: hidden;
+}
+
+.bar-fill {
+  position: absolute;
+  inset: auto 0 0 0;
+  min-height: 10px;
+  background: linear-gradient(180deg, rgba(221, 176, 62, 0.92), rgba(170, 117, 24, 0.96));
+  border-radius: 12px 12px 0 0;
+}
+
+.table-wrap {
+  overflow-x: auto;
+}
+
+.data-table {
+  width: 100%;
+  border-collapse: collapse;
+}
+
+.data-table th,
+.data-table td {
+  padding: 12px 10px;
+  border-bottom: 1px solid rgba(89, 67, 35, 0.08);
+  vertical-align: top;
+}
+
+.data-table th {
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+  text-align: left;
+}
+
+.data-table td:nth-child(1),
+.data-table td:nth-child(3),
+.data-table td:nth-child(4),
+.data-table td:nth-child(5),
+.data-table td:nth-child(6),
+.data-table td:nth-child(7) {
+  text-align: right;
+}
+
+.error-cell {
+  max-width: 280px;
+  color: var(--muted);
+}
+
+.runtime-list {
+  display: grid;
+  gap: 12px;
+  margin: 0;
+}
+
+.runtime-list div {
+  padding: 12px 14px;
+  border-radius: 14px;
+  background: rgba(255, 252, 247, 0.8);
+  border: 1px solid rgba(126, 96, 47, 0.08);
+}
+
+.runtime-list dt {
+  margin-bottom: 6px;
+  color: var(--muted);
+  font-size: 0.82rem;
+  font-weight: 700;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+
+.runtime-list dd {
+  margin: 0;
+}
+
+.runtime-error {
+  overflow-wrap: anywhere;
+}
+
+.inventory-block + .inventory-block {
+  margin-top: 18px;
+}
+
+.inventory-block h3 {
+  margin: 0 0 10px;
+  font-size: 1rem;
+}
+
+.inventory-list {
+  display: grid;
+  gap: 10px;
+  padding: 0;
+  margin: 0;
+  list-style: none;
+}
+
+.inventory-list li {
+  display: flex;
+  justify-content: space-between;
+  gap: 12px;
+  align-items: center;
+  padding: 12px 14px;
+  border-radius: 14px;
+  background: rgba(255, 252, 247, 0.78);
+  border: 1px solid rgba(126, 96, 47, 0.08);
+}
+
+.inventory-list code {
+  display: block;
+  margin-top: 4px;
+  font-size: 0.82rem;
+  color: var(--muted);
+}
+
+.inline-form {
+  grid-template-columns: minmax(0, 1fr) auto;
+  align-items: end;
+  margin-bottom: 16px;
+}
+
+.action-row {
+  display: flex;
+  gap: 8px;
+  justify-content: flex-end;
+}
+
+.code-block {
+  margin: 0;
+  padding: 16px;
+  border-radius: 14px;
+  background: oklch(0.205 0.02 85);
+  color: oklch(0.93 0.02 96);
+  overflow-x: auto;
+  line-height: 1.55;
+}
+
+.empty-state {
+  padding: 18px 6px;
+}
+
+@media (hover: hover) {
+  .button--ghost:hover,
+  .button--secondary:hover,
+  .button--danger:hover {
+    border-color: rgba(163, 123, 35, 0.28);
+    background: rgba(255, 255, 255, 0.95);
+  }
+
+  .button--primary:hover {
+    filter: brightness(1.02);
+  }
+}
+
+@media (max-width: 1080px) {
+  .auth-layout,
+  .main-grid,
+  .control-grid,
+  .summary-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .settings-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .topbar,
+  .banner {
+    flex-direction: column;
+    align-items: stretch;
+  }
+
+  .key-display {
+    justify-items: stretch;
+  }
+}
+
+@media (max-width: 720px) {
+  .console-shell,
+  .auth-layout {
+    width: min(calc(100% - 20px), var(--content-width));
+  }
+
+  .auth-panel,
+  .panel,
+  .summary-card,
+  .banner {
+    padding: 16px;
+    border-radius: 16px;
+  }
+
+  .bar-strip {
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+  }
+
+  .data-table td:nth-child(1),
+  .data-table td:nth-child(3),
+  .data-table td:nth-child(4),
+  .data-table td:nth-child(5),
+  .data-table td:nth-child(6),
+  .data-table td:nth-child(7) {
+    text-align: left;
+  }
+
+  .action-row {
+    flex-direction: column;
+  }
+
+  .inline-form {
+    grid-template-columns: 1fr;
+  }
+}
+
+@media (prefers-reduced-motion: reduce) {
+  *,
+  *::before,
+  *::after {
+    animation: none !important;
+    transition-duration: 0.01ms !important;
+    scroll-behavior: auto !important;
+  }
+}

app/templates/base.html

@@ -0,0 +1,19 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{% block title %}{{ app_name }}{% endblock %}</title>
+    <link rel="preconnect" href="https://fonts.googleapis.com" />
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
+    <link
+      href="https://fonts.googleapis.com/css2?family=Public+Sans:wght@400;500;600;700;800&family=JetBrains+Mono:wght@400;600&display=swap"
+      rel="stylesheet"
+    />
+    <link rel="stylesheet" href="{{ request.url_for('static', path='/styles.css') }}" />
+    {% block head %}{% endblock %}
+  </head>
+  <body class="{% block body_class %}{% endblock %}">
+    {% block body %}{% endblock %}
+  </body>
+</html>

app/templates/dashboard.html

@@ -0,0 +1,357 @@
+{% extends "base.html" %}
+
+{% block title %}{{ app_name }} | Dashboard{% endblock %}
+{% block head %}
+  <script defer src="{{ request.url_for('static', path='/dashboard.js') }}"></script>
+{% endblock %}
+
+{% block body %}
+  <main class="console-shell" data-metrics-url="/admin/metrics">
+    <header class="topbar">
+      <div>
+        <p class="eyebrow">Operations console</p>
+        <h1>{{ app_name }}</h1>
+        <p class="topbar-copy">
+          Real-CUGAN control plane for serial CPU inference. Last server refresh: {{ server_time }}.
+        </p>
+      </div>
+      <div class="topbar-actions">
+        <div class="status-chip {% if runtime_status.busy %}status-chip--warn{% else %}status-chip--ok{% endif %}">
+          <span class="status-dot"></span>
+          {% if runtime_status.busy %}Job running{% else %}Idle{% endif %}
+        </div>
+        <form method="post" action="/admin/logout">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          <button type="submit" class="button button--ghost">Sign out</button>
+        </form>
+      </div>
+    </header>
+
+    {% if flash %}
+      <div class="flash flash--{{ flash.level }}">{{ flash.message }}</div>
+    {% endif %}
+
+    {% if issued_key %}
+      <section class="banner banner--key">
+        <div>
+          <p class="eyebrow">New API key</p>
+          <h2>Copy it now</h2>
+          <p>This secret is shown only once. Save it in your client or secret manager before refreshing.</p>
+        </div>
+        <div class="key-display">
+          <code id="issued-api-key">{{ issued_key }}</code>
+          <button type="button" class="button button--secondary" data-copy-target="issued-api-key">
+            Copy key
+          </button>
+        </div>
+      </section>
+    {% endif %}
+
+    <section class="summary-grid">
+      <article class="summary-card">
+        <span class="metric-label">Total jobs</span>
+        <strong data-metric="total">{{ metrics.total }}</strong>
+        <p>All requests recorded in local SQLite state.</p>
+      </article>
+      <article class="summary-card">
+        <span class="metric-label">Succeeded</span>
+        <strong data-metric="succeeded">{{ metrics.succeeded }}</strong>
+        <p>Successful renders returned to API clients.</p>
+      </article>
+      <article class="summary-card">
+        <span class="metric-label">Failed</span>
+        <strong data-metric="failed">{{ metrics.failed }}</strong>
+        <p>Includes rejected images and runtime configuration errors.</p>
+      </article>
+      <article class="summary-card">
+        <span class="metric-label">Average duration</span>
+        <strong data-metric="avg_duration_ms">{{ metrics.avg_duration_ms }} ms</strong>
+        <p>Measured across completed jobs with duration available.</p>
+      </article>
+    </section>
+
+    <section class="main-grid">
+      <div class="main-column">
+        <section class="panel panel--chart">
+          <div class="panel-heading">
+            <div>
+              <p class="eyebrow">Activity</p>
+              <h2>Daily job rhythm</h2>
+            </div>
+            <p class="panel-note">Seven-day view, useful for checking whether the Space is actually being used.</p>
+          </div>
+          <div class="bar-strip" id="daily-chart">
+            {% for item in daily_counts %}
+              <div class="bar-item">
+                <div class="bar-track">
+                  <span
+                    class="bar-fill"
+                    style="height: {{ ((item.count / max_daily_count) * 100)|round(2) if max_daily_count else 0 }}%;"
+                  ></span>
+                </div>
+                <strong>{{ item.count }}</strong>
+                <span>{{ item.day[5:] }}</span>
+              </div>
+            {% else %}
+              <div class="empty-state">No jobs recorded yet.</div>
+            {% endfor %}
+          </div>
+        </section>
+
+        <section class="panel">
+          <div class="panel-heading">
+            <div>
+              <p class="eyebrow">Recent jobs</p>
+              <h2>Execution log</h2>
+            </div>
+            <p class="panel-note">Last 30 jobs, newest first.</p>
+          </div>
+          <div class="table-wrap">
+            <table class="data-table">
+              <thead>
+                <tr>
+                  <th>ID</th>
+                  <th>Status</th>
+                  <th>Input</th>
+                  <th>Model</th>
+                  <th>Tile</th>
+                  <th>Duration</th>
+                  <th>Created</th>
+                  <th>Error</th>
+                </tr>
+              </thead>
+              <tbody>
+                {% for job in jobs %}
+                  <tr>
+                    <td class="mono">#{{ job.id }}</td>
+                    <td>
+                      <span class="status-pill status-pill--{{ job.status }}">{{ job.status }}</span>
+                    </td>
+                    <td class="mono">
+                      {{ job.input_width or "-" }}×{{ job.input_height or "-" }}
+                    </td>
+                    <td class="mono">{{ job.scale }}x / {{ job.model_variant }}</td>
+                    <td class="mono">{{ job.tile_mode_used if job.tile_mode_used is not none else job.tile_mode_requested }}</td>
+                    <td class="mono">{{ job.duration_ms if job.duration_ms is not none else "-" }}</td>
+                    <td class="mono">{{ job.created_at[:19].replace("T", " ") }}</td>
+                    <td class="error-cell">{{ job.error_message or "-" }}</td>
+                  </tr>
+                {% else %}
+                  <tr>
+                    <td colspan="8" class="empty-state">No jobs recorded yet.</td>
+                  </tr>
+                {% endfor %}
+              </tbody>
+            </table>
+          </div>
+        </section>
+      </div>
+
+      <aside class="side-column">
+        <section class="panel panel--status">
+          <div class="panel-heading">
+            <div>
+              <p class="eyebrow">Runtime</p>
+              <h2>Service posture</h2>
+            </div>
+            <p class="panel-note">{{ space_hint.cpu_tier }}, {{ space_hint.cpu_spec }}</p>
+          </div>
+          <dl class="runtime-list">
+            <div>
+              <dt>Inference lock</dt>
+              <dd>{% if runtime_status.busy %}Busy{% else %}Open{% endif %}</dd>
+            </div>
+            <div>
+              <dt>Vendor code</dt>
+              <dd>{% if runtime_status.vendor_ready %}Cached{% else %}Lazy fetch{% endif %}</dd>
+            </div>
+            <div>
+              <dt>Loaded models</dt>
+              <dd>
+                {% if runtime_status.loaded_models %}
+                  {{ runtime_status.loaded_models|join(", ") }}
+                {% else %}
+                  None yet
+                {% endif %}
+              </dd>
+            </div>
+            <div>
+              <dt>Last success</dt>
+              <dd>{{ metrics.last_success_at or "None yet" }}</dd>
+            </div>
+            <div>
+              <dt>Last runtime error</dt>
+              <dd class="runtime-error">{{ runtime_status.last_runtime_error or "None" }}</dd>
+            </div>
+          </dl>
+        </section>
+
+        <section class="panel">
+          <div class="panel-heading">
+            <div>
+              <p class="eyebrow">Models</p>
+              <h2>Weight inventory</h2>
+            </div>
+            <p class="panel-note">Each row maps to a file expected in the local <code>weights/</code> directory.</p>
+          </div>
+          {% for scale, items in models_by_scale.items()|sort %}
+            <div class="inventory-block">
+              <h3>{{ scale }}x</h3>
+              <ul class="inventory-list">
+                {% for item in items %}
+                  <li>
+                    <div>
+                      <strong>{{ item.variant }}</strong>
+                      <code>{{ item.filename }}</code>
+                    </div>
+                    <span class="inventory-state {% if item.present %}inventory-state--ok{% else %}inventory-state--miss{% endif %}">
+                      {% if item.present %}present{% else %}missing{% endif %}
+                    </span>
+                  </li>
+                {% endfor %}
+              </ul>
+            </div>
+          {% endfor %}
+        </section>
+      </aside>
+    </section>
+
+    <section class="control-grid">
+      <section class="panel">
+        <div class="panel-heading">
+          <div>
+            <p class="eyebrow">Runtime controls</p>
+            <h2>Default inference profile</h2>
+          </div>
+          <p class="panel-note">These values become the API defaults when the caller omits form fields.</p>
+        </div>
+        <form method="post" action="/admin/settings" class="settings-grid">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          {% for field in settings_spec %}
+            <label class="field">
+              <span>{{ field.label }}</span>
+              {% if field.type == "select" %}
+                <select name="{{ field.name }}">
+                  {% for option in field.options %}
+                    <option value="{{ option }}" {% if settings[field.name] == option %}selected{% endif %}>{{ option }}</option>
+                  {% endfor %}
+                </select>
+              {% else %}
+                <input type="text" name="{{ field.name }}" value="{{ settings[field.name] }}" />
+              {% endif %}
+              <small>{{ field.help }}</small>
+            </label>
+          {% endfor %}
+          <button type="submit" class="button button--primary">Save runtime settings</button>
+        </form>
+      </section>
+
+      <section class="panel">
+        <div class="panel-heading">
+          <div>
+            <p class="eyebrow">Access control</p>
+            <h2>API keys</h2>
+          </div>
+          <p class="panel-note">Clients need either <code>X-API-Key</code> or <code>Authorization: Bearer</code>.</p>
+        </div>
+        <form method="post" action="/admin/api-keys" class="inline-form">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          <input type="text" name="name" placeholder="Key label, e.g. production-bot" required />
+          <button type="submit" class="button button--primary">Create key</button>
+        </form>
+        <div class="table-wrap">
+          <table class="data-table">
+            <thead>
+              <tr>
+                <th>Name</th>
+                <th>Prefix</th>
+                <th>State</th>
+                <th>Created</th>
+                <th>Last used</th>
+                <th>Actions</th>
+              </tr>
+            </thead>
+            <tbody>
+              {% for api_key in api_keys %}
+                <tr>
+                  <td>{{ api_key.name }}</td>
+                  <td class="mono">{{ api_key.key_prefix }}...</td>
+                  <td>
+                    <span class="status-pill status-pill--{% if api_key.enabled %}succeeded{% else %}failed{% endif %}">
+                      {% if api_key.enabled %}enabled{% else %}disabled{% endif %}
+                    </span>
+                  </td>
+                  <td class="mono">{{ api_key.created_at[:19].replace("T", " ") }}</td>
+                  <td class="mono">{{ api_key.last_used_at[:19].replace("T", " ") if api_key.last_used_at else "-" }}</td>
+                  <td>
+                    <div class="action-row">
+                      <form method="post" action="/admin/api-keys/{{ api_key.id }}/toggle">
+                        <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+                        <input type="hidden" name="enabled" value="{% if api_key.enabled %}0{% else %}1{% endif %}" />
+                        <button type="submit" class="button button--ghost">
+                          {% if api_key.enabled %}Disable{% else %}Enable{% endif %}
+                        </button>
+                      </form>
+                      <form method="post" action="/admin/api-keys/{{ api_key.id }}/delete">
+                        <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+                        <button type="submit" class="button button--danger">Delete</button>
+                      </form>
+                    </div>
+                  </td>
+                </tr>
+              {% else %}
+                <tr>
+                  <td colspan="6" class="empty-state">No API keys yet.</td>
+                </tr>
+              {% endfor %}
+            </tbody>
+          </table>
+        </div>
+      </section>
+
+      <section class="panel">
+        <div class="panel-heading">
+          <div>
+            <p class="eyebrow">Security</p>
+            <h2>Admin password</h2>
+          </div>
+          <p class="panel-note">Rotate this after first deployment if you used a temporary secret.</p>
+        </div>
+        <form method="post" action="/admin/password" class="stack-form">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          <label>
+            <span>Current password</span>
+            <input type="password" name="current_password" autocomplete="current-password" required />
+          </label>
+          <label>
+            <span>New password</span>
+            <input type="password" name="new_password" autocomplete="new-password" minlength="10" required />
+          </label>
+          <label>
+            <span>Confirm new password</span>
+            <input type="password" name="confirm_password" autocomplete="new-password" minlength="10" required />
+          </label>
+          <button type="submit" class="button button--secondary">Update admin password</button>
+        </form>
+      </section>
+
+      <section class="panel">
+        <div class="panel-heading">
+          <div>
+            <p class="eyebrow">API usage</p>
+            <h2>Client example</h2>
+          </div>
+          <p class="panel-note">Replace the placeholder key and image path before use.</p>
+        </div>
+        <pre class="code-block"><code>curl -X POST "$SPACE_URL/api/v1/upscale" \
+  -H "X-API-Key: rcg_replace_me" \
+  -F "file=@input.png" \
+  -F "scale={{ settings.default_scale }}" \
+  -F "variant={{ settings.default_variant }}" \
+  -F "alpha={{ settings.default_alpha }}" \
+  -F "response_format=png" \
+  -o output.png</code></pre>
+      </section>
+    </section>
+  </main>
+{% endblock %}

app/templates/login.html

@@ -0,0 +1,85 @@
+{% extends "base.html" %}
+
+{% block title %}{{ app_name }} | Admin{% endblock %}
+{% block body_class %}auth-shell{% endblock %}
+
+{% block body %}
+  <main class="auth-layout">
+    <section class="auth-panel auth-panel--hero">
+      <p class="eyebrow">Real-CUGAN control plane</p>
+      <h1>Private anime upscaling, tuned for slow CPU and long-running jobs.</h1>
+      <p class="auth-copy">
+        This panel controls API keys, runtime limits, model availability and recent job health.
+        It is designed for Hugging Face CPU Basic, where stability matters more than throughput.
+      </p>
+      <div class="auth-grid">
+        <article>
+          <span class="metric-label">Deployment target</span>
+          <strong>Hugging Face Docker Space</strong>
+          <p>Single-process FastAPI, session auth, SQLite state.</p>
+        </article>
+        <article>
+          <span class="metric-label">Inference mode</span>
+          <strong>Real-CUGAN on CPU</strong>
+          <p>Whole-image first, tile fallback when memory pressure appears.</p>
+        </article>
+        <article>
+          <span class="metric-label">Traffic posture</span>
+          <strong>Serial requests</strong>
+          <p>One active upscale at a time, API key gate on every job.</p>
+        </article>
+      </div>
+    </section>
+
+    <section class="auth-panel auth-panel--form">
+      {% if flash %}
+        <div class="flash flash--{{ flash.level }}">{{ flash.message }}</div>
+      {% endif %}
+
+      {% if admin_configured %}
+        <div class="panel-heading">
+          <p class="eyebrow">Admin access</p>
+          <h2>Sign in</h2>
+          <p>Use the local admin account for the control plane.</p>
+        </div>
+        <form method="post" action="/admin/login" class="stack-form">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          <label>
+            <span>Username</span>
+            <input type="text" name="username" value="{{ admin_username }}" autocomplete="username" required />
+          </label>
+          <label>
+            <span>Password</span>
+            <input type="password" name="password" autocomplete="current-password" required />
+          </label>
+          <button type="submit" class="button button--primary">Sign in</button>
+        </form>
+      {% else %}
+        <div class="panel-heading">
+          <p class="eyebrow">First boot</p>
+          <h2>Initialize the admin account</h2>
+          <p>
+            No admin user exists yet. Set the first password here, or provide
+            <code>ADMIN_PASSWORD</code> as a Space secret before launch.
+          </p>
+        </div>
+        <form method="post" action="/admin/bootstrap" class="stack-form">
+          <input type="hidden" name="csrf" value="{{ csrf_token }}" />
+          <label>
+            <span>Admin username</span>
+            <input type="text" value="{{ admin_username }}" disabled />
+          </label>
+          <label>
+            <span>New password</span>
+            <input type="password" name="password" autocomplete="new-password" minlength="10" required />
+          </label>
+          <label>
+            <span>Confirm password</span>
+            <input type="password" name="confirm_password" autocomplete="new-password" minlength="10" required />
+          </label>
+          <button type="submit" class="button button--primary">Create admin account</button>
+        </form>
+      {% endif %}
+    </section>
+  </main>
+{% endblock %}

app/vendor/__init__.py

@@ -0,0 +1 @@
+"""Vendor bootstrap package."""

app/vendor/upcunet_v3.py

@@ -0,0 +1,1334 @@
+'''
+cache_mode:
+0:使用cache缓存必要参数
+1:使用cache缓存必要参数，对cache进行8bit量化节省显存，带来小许延时增长
+2:不使用cache，耗时约为mode0的2倍，但是显存不受输入图像分辨率限制，tile_mode填得够大，1.5G显存可超任意比例
+'''
+import torch,pdb
+from torch import nn as nn
+from torch.nn import functional as F
+import os,sys
+import numpy as np
+root_path=os.path.abspath('.')
+sys.path.append(root_path)
+def q(inp,cache_mode):
+    maxx = inp.max()
+    minn = inp.min()
+    delta = maxx - minn
+    if(cache_mode==2):
+        return ((inp-minn)/delta*255).round().byte().cpu(),delta,minn,inp.device#大概3倍延时#太慢了，屏蔽该模式
+    elif(cache_mode==1):
+        return ((inp-minn)/delta*255).round().byte(),delta,minn,inp.device#不用CPU转移
+def dq(inp,if_half,cache_mode,delta,minn,device):
+    if(cache_mode==2):
+        if(if_half==True):return inp.to(device).half()/255*delta+minn
+        else:return inp.to(device).float()/255*delta+minn
+    elif(cache_mode==1):
+        if(if_half==True):return inp.half()/255*delta+minn#不用CPU转移
+        else:return inp.float()/255*delta+minn
+class SEBlock(nn.Module):
+    def __init__(self, in_channels, reduction=8, bias=False):
+        super(SEBlock, self).__init__()
+        self.conv1 = nn.Conv2d(in_channels, in_channels // reduction, 1, 1, 0, bias=bias)
+        self.conv2 = nn.Conv2d(in_channels // reduction, in_channels, 1, 1, 0, bias=bias)
+
+    def forward(self, x):
+        if ("Half" in x.type()):  # torch.HalfTensor/torch.cuda.HalfTensor
+            x0 = torch.mean(x.float(), dim=(2, 3), keepdim=True).half()
+        else:
+            x0 = torch.mean(x, dim=(2, 3), keepdim=True)
+        x0 = self.conv1(x0)
+        x0 = F.relu(x0, inplace=True)
+        x0 = self.conv2(x0)
+        x0 = torch.sigmoid(x0)
+        x = torch.mul(x, x0)
+        return x
+
+    def forward_mean(self, x,x0):
+        x0 = self.conv1(x0)
+        x0 = F.relu(x0, inplace=True)
+        x0 = self.conv2(x0)
+        x0 = torch.sigmoid(x0)
+        x = torch.mul(x, x0)
+        return x
+class UNetConv(nn.Module):
+    def __init__(self, in_channels, mid_channels, out_channels, se):
+        super(UNetConv, self).__init__()
+        self.conv = nn.Sequential(
+            nn.Conv2d(in_channels, mid_channels, 3, 1, 0),
+            nn.LeakyReLU(0.1, inplace=True),
+            nn.Conv2d(mid_channels, out_channels, 3, 1, 0),
+            nn.LeakyReLU(0.1, inplace=True),
+        )
+        if se:
+            self.seblock = SEBlock(out_channels, reduction=8, bias=True)
+        else:
+            self.seblock = None
+
+    def forward(self, x):
+        z = self.conv(x)
+        if self.seblock is not None:
+            z = self.seblock(z)
+        return z
+class UNet1(nn.Module):
+    def __init__(self, in_channels, out_channels, deconv):
+        super(UNet1, self).__init__()
+        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
+        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
+        self.conv2 = UNetConv(64, 128, 64, se=True)
+        self.conv2_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
+        self.conv3 = nn.Conv2d(64, 64, 3, 1, 0)
+
+        if deconv:
+            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 4, 2, 3)
+        else:
+            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
+
+        for m in self.modules():
+            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-4, -4, -4, -4))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2(x2)
+        x2 = self.conv2_up(x2)
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x3 = self.conv3(x1 + x2)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        z = self.conv_bottom(x3)
+        return z
+
+    def forward_a(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-4, -4, -4, -4))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2.conv(x2)
+        return x1,x2
+
+    def forward_b(self, x1,x2):
+        x2 = self.conv2_up(x2)
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x3 = self.conv3(x1 + x2)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        z = self.conv_bottom(x3)
+        return z
+class UNet1x3(nn.Module):
+    def __init__(self, in_channels, out_channels, deconv):
+        super(UNet1x3, self).__init__()
+        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
+        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
+        self.conv2 = UNetConv(64, 128, 64, se=True)
+        self.conv2_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
+        self.conv3 = nn.Conv2d(64, 64, 3, 1, 0)
+
+        if deconv:
+            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 5, 3, 2)
+        else:
+            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
+
+        for m in self.modules():
+            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-4, -4, -4, -4))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2(x2)
+        x2 = self.conv2_up(x2)
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x3 = self.conv3(x1 + x2)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        z = self.conv_bottom(x3)
+        return z
+
+    def forward_a(self, x):
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-4, -4, -4, -4))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2.conv(x2)
+        return x1,x2
+
+    def forward_b(self, x1,x2):
+        x2 = self.conv2_up(x2)
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x3 = self.conv3(x1 + x2)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        z = self.conv_bottom(x3)
+        return z
+class UNet2(nn.Module):
+    def __init__(self, in_channels, out_channels, deconv):
+        super(UNet2, self).__init__()
+
+        self.conv1 = UNetConv(in_channels, 32, 64, se=False)
+        self.conv1_down = nn.Conv2d(64, 64, 2, 2, 0)
+        self.conv2 = UNetConv(64, 64, 128, se=True)
+        self.conv2_down = nn.Conv2d(128, 128, 2, 2, 0)
+        self.conv3 = UNetConv(128, 256, 128, se=True)
+        self.conv3_up = nn.ConvTranspose2d(128, 128, 2, 2, 0)
+        self.conv4 = UNetConv(128, 64, 64, se=True)
+        self.conv4_up = nn.ConvTranspose2d(64, 64, 2, 2, 0)
+        self.conv5 = nn.Conv2d(64, 64, 3, 1, 0)
+
+        if deconv:
+            self.conv_bottom = nn.ConvTranspose2d(64, out_channels, 4, 2, 3)
+        else:
+            self.conv_bottom = nn.Conv2d(64, out_channels, 3, 1, 0)
+
+        for m in self.modules():
+            if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d)):
+                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
+            elif isinstance(m, nn.Linear):
+                nn.init.normal_(m.weight, 0, 0.01)
+                if m.bias is not None:
+                    nn.init.constant_(m.bias, 0)
+
+    def forward(self, x,alpha=1):
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-16, -16, -16, -16))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2(x2)
+        x3 = self.conv2_down(x2)
+        x2 = F.pad(x2, (-4, -4, -4, -4))
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        x3 = self.conv3(x3)
+        x3 = self.conv3_up(x3)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        x4 = self.conv4(x2 + x3)
+        x4*=alpha
+        x4 = self.conv4_up(x4)
+        x4 = F.leaky_relu(x4, 0.1, inplace=True)
+        x5 = self.conv5(x1 + x4)
+        x5 = F.leaky_relu(x5, 0.1, inplace=True)
+        z = self.conv_bottom(x5)
+        return z
+
+    def forward_a(self, x):#conv234结尾有se
+        x1 = self.conv1(x)
+        x2 = self.conv1_down(x1)
+        x1 = F.pad(x1, (-16, -16, -16, -16))
+        x2 = F.leaky_relu(x2, 0.1, inplace=True)
+        x2 = self.conv2.conv(x2)
+        return x1,x2
+
+    def forward_b(self, x2):  # conv234结尾有se
+        x3 = self.conv2_down(x2)
+        x2 = F.pad(x2, (-4, -4, -4, -4))
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        x3 = self.conv3.conv(x3)
+        return x2,x3
+
+    def forward_c(self, x2,x3):  # conv234结尾有se
+        x3 = self.conv3_up(x3)
+        x3 = F.leaky_relu(x3, 0.1, inplace=True)
+        x4 = self.conv4.conv(x2 + x3)
+        return x4
+
+    def forward_d(self, x1,x4):  # conv234结尾有se
+        x4 = self.conv4_up(x4)
+        x4 = F.leaky_relu(x4, 0.1, inplace=True)
+        x5 = self.conv5(x1 + x4)
+        x5 = F.leaky_relu(x5, 0.1, inplace=True)
+
+        z = self.conv_bottom(x5)
+        return z
+class UpCunet2x(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3):
+        super(UpCunet2x, self).__init__()
+        self.unet1 = UNet1(in_channels, out_channels, deconv=True)
+        self.unet2 = UNet2(in_channels, out_channels, deconv=False)
+    def forward(self, x,tile_mode,cache_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if ("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode==0):#���tile
+            ph = ((h0 - 1) // 2 + 1) * 2
+            pw = ((w0 - 1) // 2 + 1) * 2
+            x = F.pad(x, (18, 18 + pw - w0, 18, 18 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 2, :w0 * 2]
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//2*2+2#能被2整除
+            else:
+                crop_size_h=((h0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//2*2+2#能被2整除
+            crop_size=(crop_size_h,crop_size_w)
+        elif(tile_mode>=2):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t2=tile_mode*2
+            crop_size=(((h0-1)//t2*t2+t2)//tile_mode,((w0-1)//t2*t2+t2)//tile_mode)
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(18,18+pw-w0,18,18+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        tmp_dict={}
+        for i in range(0,h-36,crop_size[0]):
+            tmp_dict[i]={}
+            for j in range(0,w-36,crop_size[1]):
+                x_crop=x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36]
+                n,c1,h1,w1=x_crop.shape
+                tmp0,x_crop = self.unet1.forward_a(x_crop)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+                tmp_dict[i][j]=(tmp0,x_crop)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0, x_crop=tmp_dict[i][j]
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                opt_unet1 = F.pad(opt_unet1,(-20,-20,-20,-20))
+                if(cache_mode):opt_unet1,tmp_x1=q(opt_unet1,cache_mode), q(tmp_x1,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2)
+        se_mean1/=n_patch
+        if (if_half):se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2=tmp_dict[i][j]
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x3=q(tmp_x3,cache_mode)
+                se_mean0+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2,tmp_x3)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2,tmp_x3=tmp_dict[i][j]
+                if(cache_mode):tmp_x3=dq(tmp_x3[0],if_half,cache_mode,tmp_x3[1],tmp_x3[2],tmp_x3[3])
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean0)
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x4=q(tmp_x4,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x4)
+        se_mean1/=n_patch
+        res = torch.zeros((n, c, h * 2 - 72, w * 2 - 72),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                x,tmp_x1, tmp_x4=tmp_dict[i][j]
+                if(cache_mode):tmp_x4=dq(tmp_x4[0],if_half,cache_mode,tmp_x4[1],tmp_x4[2],tmp_x4[3])
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean1)
+                if(cache_mode):tmp_x1=dq(tmp_x1[0],if_half,cache_mode,tmp_x1[1],tmp_x1[2],tmp_x1[3])
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                if(cache_mode):x = dq(x[0], if_half, cache_mode,x[1], x[2], x[3])
+                del tmp_dict[i][j]
+                x = torch.add(x0, x)#x0是unet2的最终输出
+                if(pro):
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = (x*255).round().clamp_(0, 255).byte()
+        del tmp_dict
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*2,:w0*2]
+        return res
+    def forward_gap_sync(self, x,tile_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode==0):#不tile
+            ph = ((h0 - 1) // 2 + 1) * 2
+            pw = ((w0 - 1) // 2 + 1) * 2
+            x = F.pad(x, (18, 18 + pw - w0, 18, 18 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 2, :w0 * 2]
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//2*2+2#能被2整除
+            else:
+                crop_size_h=((h0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//2*2+2#能被2整除
+            crop_size=(crop_size_h,crop_size_w)#6.6G
+        elif(tile_mode>=2):#hw都减半
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t2=tile_mode*2
+            crop_size=(((h0-1)//t2*t2+t2)//tile_mode,((w0-1)//t2*t2+t2)//tile_mode)
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(18,18+pw-w0,18,18+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        h1,w1=crop_size[0]+36,crop_size[1]+36
+        ######stage1
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+        se_mean0/=n_patch
+        ######stage1+state2
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                se_mean1+=tmp_se_mean
+        se_mean1/=n_patch
+        ######stage1+state2+state3
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                se_mean2+=tmp_se_mean
+        se_mean2/=n_patch
+        #########stage1+state2+state3+stage4
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        if(if_half):
+            se_mean3=se_mean3.half()
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                se_mean3+=tmp_se_mean
+        se_mean3/=n_patch
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 2 - 72, w * 2 - 72),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                if(pro):
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = (x_crop* 255.0).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*2,:w0*2]
+        return res
+    def forward_fast_rough(self, x,tile_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if ("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode<3):return self.forward(x,tile_mode,1,alpha,pro)#至少切成3x3
+        elif(tile_mode>=3):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            if (tile_mode < 3): return self.forward(x, tile_mode, 1, alpha,pro)
+            t2=tile_mode*2
+            crop_size=(((h0-1)//t2*t2+t2)//tile_mode,((w0-1)//t2*t2+t2)//tile_mode)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(18,18+pw-w0,18,18+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        h1,w1=crop_size[0]+36,crop_size[1]+36
+        n_patch=0
+        ###########stage1+state2+state3+stage4
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-36,crop_size[0]):
+            if((i//crop_size[0])%2==0):continue
+            for j in range(0,w-36,crop_size[1]):
+                if ((j//crop_size[1]) % 2 == 0): continue
+                n_patch+=1
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                if(if_half):se_mean0 += torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean0 += torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if(if_half):se_mean1 += torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean1 += torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):se_mean2 += torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean2 += torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                if(if_half):se_mean3 += torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean3 += torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+        # print("2x-n_patch=%s,tile_mode=%s" % (n_patch,tile_mode))
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 2 - 72, w * 2 - 72),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-36,crop_size[0]):
+            for j in range(0,w-36,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+36,j:j+crop_size[1]+36])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3/n_patch)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                if(pro):
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 2:i * 2 + h1 * 2 - 72, j * 2:j * 2 + w1 * 2 - 72] = (x_crop* 255.0).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*2,:w0*2]
+        return res
+class UpCunet3x(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3):
+        super(UpCunet3x, self).__init__()
+        self.unet1 = UNet1x3(in_channels, out_channels, deconv=True)
+        self.unet2 = UNet2(in_channels, out_channels, deconv=False)
+    def forward(self, x,tile_mode,cache_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode==0):#不tile
+            ph = ((h0 - 1) // 4 + 1) * 4
+            pw = ((w0 - 1) // 4 + 1) * 4
+            x = F.pad(x, (14, 14 + pw - w0, 14, 14 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 3, :w0 * 3]
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//8*8+8)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//4*4+4#能被2整除
+            else:
+                crop_size_h=((h0-1)//8*8+8)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//4*4+4#能被2整除
+            crop_size=(crop_size_h,crop_size_w)
+        elif (tile_mode >= 2):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t4 = tile_mode * 4
+            crop_size = (((h0 - 1) // t4 * t4 + t4) // tile_mode, ((w0 - 1) // t4 * t4 + t4) // tile_mode)
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(14,14+pw-w0,14,14+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        tmp_dict={}
+        for i in range(0,h-28,crop_size[0]):
+            tmp_dict[i]={}
+            for j in range(0,w-28,crop_size[1]):
+                x_crop=x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28]
+                n,c1,h1,w1=x_crop.shape
+                tmp0,x_crop = self.unet1.forward_a(x_crop)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+                tmp_dict[i][j]=(tmp0,x_crop)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0, x_crop=tmp_dict[i][j]
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                opt_unet1 = F.pad(opt_unet1,(-20,-20,-20,-20))
+                if(cache_mode):opt_unet1,tmp_x1=q(opt_unet1,cache_mode), q(tmp_x1,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2)
+        se_mean1/=n_patch
+        if (if_half):se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2=tmp_dict[i][j]
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x3=q(tmp_x3,cache_mode)
+                se_mean0+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2,tmp_x3)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2,tmp_x3=tmp_dict[i][j]
+                if(cache_mode):tmp_x3=dq(tmp_x3[0],if_half,cache_mode,tmp_x3[1],tmp_x3[2],tmp_x3[3])
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean0)
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x4=q(tmp_x4,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x4)
+        se_mean1/=n_patch
+        res = torch.zeros((n, c, h * 3 - 84, w * 3 - 84),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                x,tmp_x1, tmp_x4=tmp_dict[i][j]
+                if(cache_mode):tmp_x4=dq(tmp_x4[0],if_half,cache_mode,tmp_x4[1],tmp_x4[2],tmp_x4[3])
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean1)
+                if(cache_mode):tmp_x1=dq(tmp_x1[0],if_half,cache_mode,tmp_x1[1],tmp_x1[2],tmp_x1[3])
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                if(cache_mode):x = dq(x[0], if_half, cache_mode,x[1], x[2], x[3])
+                del tmp_dict[i][j]
+                x = torch.add(x0, x)#x0是unet2的最终输出
+                if(pro):
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = (x*255).round().clamp_(0, 255).byte()
+        del tmp_dict
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*3,:w0*3]
+        return res
+    def forward_gap_sync(self, x,tile_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode==0):#不tile
+            ph = ((h0 - 1) // 4 + 1) * 4
+            pw = ((w0 - 1) // 4 + 1) * 4
+            x = F.pad(x, (14, 14 + pw - w0, 14, 14 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 3, :w0 * 3]
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//8*8+8)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//4*4+4#能被2整除
+            else:
+                crop_size_h=((h0-1)//8*8+8)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//4*4+4#能被2整除
+            crop_size=(crop_size_h,crop_size_w)
+        elif (tile_mode >= 2):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t4 = tile_mode * 4
+            crop_size = (((h0 - 1) // t4 * t4 + t4) // tile_mode, ((w0 - 1) // t4 * t4 + t4) // tile_mode)
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(14,14+pw-w0,14,14+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        h1,w1=crop_size[0]+28,crop_size[1]+28
+        ######stage1
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+        se_mean0/=n_patch
+        ######stage1+state2
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if (if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                se_mean1+=tmp_se_mean
+        se_mean1/=n_patch
+        ######stage1+state2+state3
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                se_mean2+=tmp_se_mean
+        se_mean2/=n_patch
+        #########stage1+state2+state3+stage4
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                se_mean3+=tmp_se_mean
+        se_mean3/=n_patch
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 3 - 84, w * 3 - 84),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                if(pro):
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = (x_crop* 255.0).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*3,:w0*3]
+        return res
+    def forward_fast_rough(self, x,tile_mode,alpha,pro):#1.7G
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        if(tile_mode<3):return self.forward(x,tile_mode,1,alpha,pro)#至少切成3x3
+        elif(tile_mode>=3):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            if (tile_mode < 3): return self.forward(x, tile_mode, 1, alpha, pro)
+            t4 = tile_mode * 4
+            crop_size = (((h0 - 1) // t4 * t4 + t4) // tile_mode, ((w0 - 1) // t4 * t4 + t4) // tile_mode)  # 5.6G
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(14,14+pw-w0,14,14+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        h1,w1=crop_size[0]+28,crop_size[1]+28
+        n_patch=0
+        ###########stage1+state2+state3+stage4
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-28,crop_size[0]):
+            if((i//crop_size[0])%2==0):continue
+            for j in range(0,w-28,crop_size[1]):
+                if ((j//crop_size[1]) % 2 == 0): continue
+                n_patch+=1
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                if(if_half):se_mean0 += torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean0 += torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if(if_half):se_mean1 += torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean1 += torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):se_mean2 += torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean2 += torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                if(if_half):se_mean3 += torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean3 += torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+        # print("3x-n_patch=%s,tile_mode=%s" % (n_patch,tile_mode))
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 3 - 84, w * 3 - 84),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-28,crop_size[0]):
+            for j in range(0,w-28,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+28,j:j+crop_size[1]+28])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3/n_patch)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                if(pro):
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 3:i * 3 + h1 * 3 - 84, j * 3:j * 3 + w1 * 3 - 84] = (x_crop* 255.0).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*3,:w0*3]
+        return res
+class UpCunet4x(nn.Module):
+    def __init__(self, in_channels=3, out_channels=3):
+        super(UpCunet4x, self).__init__()
+        self.unet1 = UNet1(in_channels, 64, deconv=True)
+        self.unet2 = UNet2(64, 64, deconv=False)
+        self.ps=nn.PixelShuffle(2)
+        self.conv_final=nn.Conv2d(64,12,3,1,padding=0,bias=True)
+    def forward(self, x,tile_mode,cache_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        x00 = x
+        if(tile_mode==0):#不tile
+            ph = ((h0 - 1) // 2 + 1) * 2
+            pw = ((w0 - 1) // 2 + 1) * 2
+            x = F.pad(x, (19, 19 + pw - w0, 19, 19 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x1 = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x1)
+            x=self.conv_final(x)
+            x=F.pad(x,(-1,-1,-1,-1))
+            x=self.ps(x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 4, :w0 * 4]
+            x+=F.interpolate(x00, scale_factor=4, mode='nearest')
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//2*2+2#能被2整除
+            else:
+                crop_size_h=((h0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//2*2+2#能被2整除
+            crop_size=(crop_size_h,crop_size_w)
+        elif (tile_mode >= 2):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t2 = tile_mode * 2
+            crop_size = (((h0 - 1) // t2 * t2 + t2) // tile_mode, ((w0 - 1) // t2 * t2 + t2) // tile_mode)
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(19,19+pw-w0,19,19+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        tmp_dict={}
+        for i in range(0,h-38,crop_size[0]):
+            tmp_dict[i]={}
+            for j in range(0,w-38,crop_size[1]):
+                x_crop=x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38]
+                n,c1,h1,w1=x_crop.shape
+                tmp0,x_crop = self.unet1.forward_a(x_crop)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+                tmp_dict[i][j]=(tmp0,x_crop)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0, x_crop=tmp_dict[i][j]
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                opt_unet1 = F.pad(opt_unet1,(-20,-20,-20,-20))
+                if(cache_mode):opt_unet1,tmp_x1=q(opt_unet1,cache_mode), q(tmp_x1,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2)
+        se_mean1/=n_patch
+        if (if_half):se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2=tmp_dict[i][j]
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                if(cache_mode):tmp_x2=q(tmp_x2,cache_mode)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x3=q(tmp_x3,cache_mode)
+                se_mean0+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x2,tmp_x3)
+        se_mean0/=n_patch
+        if (if_half):se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                opt_unet1,tmp_x1, tmp_x2,tmp_x3=tmp_dict[i][j]
+                if(cache_mode):tmp_x3=dq(tmp_x3[0],if_half,cache_mode,tmp_x3[1],tmp_x3[2],tmp_x3[3])
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean0)
+                if(cache_mode):tmp_x2=dq(tmp_x2[0],if_half,cache_mode,tmp_x2[1],tmp_x2[2],tmp_x2[3])
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                if(cache_mode):tmp_x4=q(tmp_x4,cache_mode)
+                se_mean1+=tmp_se_mean
+                tmp_dict[i][j]=(opt_unet1,tmp_x1,tmp_x4)
+        se_mean1/=n_patch
+        res = torch.zeros((n, c, h * 4 - 152, w * 4 - 152),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                x,tmp_x1, tmp_x4=tmp_dict[i][j]
+                if(cache_mode):tmp_x4=dq(tmp_x4[0],if_half,cache_mode,tmp_x4[1],tmp_x4[2],tmp_x4[3])
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean1)
+                if(cache_mode):tmp_x1=dq(tmp_x1[0],if_half,cache_mode,tmp_x1[1],tmp_x1[2],tmp_x1[3])
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                del tmp_x1,tmp_x4
+                if(cache_mode):x = dq(x[0], if_half, cache_mode,x[1], x[2], x[3])
+                del tmp_dict[i][j]
+                x = torch.add(x0, x)#x0是unet2的最终输出
+                x=self.conv_final(x)
+                x = F.pad(x, (-1, -1, -1, -1))
+                x=self.ps(x)
+                x00_crop=x00[:, :, i:i + h1 - 38, j:j + w1 - 38]
+                _,_,h2,w2=x00_crop.shape
+                x[:,:,:h2*4,:w2*4]+=F.interpolate(x00_crop, scale_factor=4, mode='nearest')
+                if(pro):
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = (x*255).round().clamp_(0, 255).byte()
+        del tmp_dict
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*4,:w0*4]
+        return res
+    def forward_gap_sync(self, x,tile_mode,alpha,pro):
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        x00 = x
+        if(tile_mode==0):#不tile
+            ph = ((h0 - 1) // 2 + 1) * 2
+            pw = ((w0 - 1) // 2 + 1) * 2
+            x = F.pad(x, (19, 19 + pw - w0, 19, 19 + ph - h0), 'reflect')  # 需要保证被2整除
+            x = self.unet1.forward(x)
+            x0 = self.unet2.forward(x,alpha)
+            x1 = F.pad(x, (-20, -20, -20, -20))
+            x = torch.add(x0, x1)
+            x=self.conv_final(x)
+            x=F.pad(x,(-1,-1,-1,-1))
+            x=self.ps(x)
+            if (w0 != pw or h0 != ph): x = x[:, :, :h0 * 4, :w0 * 4]
+            x+=F.interpolate(x00, scale_factor=4, mode='nearest')
+            if(pro):
+                return ((x-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+            else:
+                return (x * 255).round().clamp_(0, 255).byte()
+        elif(tile_mode==1):# 对长边减半
+            if(w0>=h0):
+                crop_size_w=((w0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_h=(h0-1)//2*2+2#能被2整除
+            else:
+                crop_size_h=((h0-1)//4*4+4)//2#减半后能被2整除，所以要先被4整除
+                crop_size_w=(w0-1)//2*2+2#能被2整除
+            crop_size=(crop_size_h,crop_size_w)
+        elif(tile_mode>=2):#hw都减半
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            t2=tile_mode*2
+            crop_size=(((h0-1)//t2*t2+t2)//tile_mode,((w0-1)//t2*t2+t2)//tile_mode)#5.6G
+        else:
+            print("tile_mode config error")
+            os._exit(233)
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(19,19+pw-w0,19,19+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        n_patch=0
+        h1,w1=crop_size[0]+38,crop_size[1]+38
+        ######stage1
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                se_mean0+=tmp_se_mean
+                n_patch+=1
+        se_mean0/=n_patch
+        ######stage1+state2
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                se_mean1+=tmp_se_mean
+        se_mean1/=n_patch
+        ######stage1+state2+state3
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                se_mean2+=tmp_se_mean
+        se_mean2/=n_patch
+        #########stage1+state2+state3+stage4
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                if(if_half):  # torch.HalfTensor/torch.cuda.HalfTensor
+                    tmp_se_mean = torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:
+                    tmp_se_mean = torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+                se_mean3+=tmp_se_mean
+        se_mean3/=n_patch
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 4 - 152, w * 4 - 152),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                x_crop=self.conv_final(x_crop)
+                x_crop = F.pad(x_crop, (-1, -1, -1, -1))
+                x_crop=self.ps(x_crop)
+                x00_crop=x00[:, :, i:i + h1 - 38, j:j + w1 - 38]
+                _,_,h2,w2=x00_crop.shape
+                x_crop[:,:,:h2*4,:w2*4]+=F.interpolate(x00_crop, scale_factor=4, mode='nearest')
+                if(pro):
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = (x_crop*255).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*4,:w0*4]
+        return res
+    def forward_fast_rough(self, x,tile_mode,alpha,pro):#1.7G
+        n, c, h0, w0 = x.shape
+        if("Half" in x.type()):if_half=True
+        else:if_half=False
+        x00 = x
+        if(tile_mode<3):return self.forward(x,tile_mode,1,alpha,pro)#至少切成3x3
+        elif(tile_mode>=3):
+            tile_mode=min(min(h0,w0)//128,int(tile_mode))#最小短边为128*128
+            if (tile_mode < 3): return self.forward(x, tile_mode, 1, alpha, pro)
+            t2=tile_mode*2
+            crop_size=(((h0-1)//t2*t2+t2)//tile_mode,((w0-1)//t2*t2+t2)//tile_mode)#5.6G
+        ph = ((h0 - 1) // crop_size[0] + 1) * crop_size[0]
+        pw = ((w0 - 1) // crop_size[1] + 1) * crop_size[1]
+        x=F.pad(x,(19,19+pw-w0,19,19+ph-h0),'reflect')
+        n,c,h,w=x.shape
+        h1,w1=crop_size[0]+38,crop_size[1]+38
+        n_patch=0
+        ###########stage1+state2+state3+stage4
+        if (if_half):se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean0=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean1=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean2=torch.zeros((n,128,1,1),device=x.device,dtype=torch.float32)
+        if (if_half):se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float16)
+        else:se_mean3=torch.zeros((n,64,1,1),device=x.device,dtype=torch.float32)
+        for i in range(0,h-38,crop_size[0]):
+            if((i//crop_size[0])%2==0):continue
+            for j in range(0,w-38,crop_size[1]):
+                if ((j//crop_size[1]) % 2 == 0): continue
+                n_patch+=1
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                if(if_half):se_mean0 += torch.mean(x_crop.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean0 += torch.mean(x_crop, dim=(2, 3),keepdim=True)
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                opt_unet1=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(opt_unet1)
+                if(if_half):se_mean1 += torch.mean(tmp_x2.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean1 += torch.mean(tmp_x2, dim=(2, 3),keepdim=True)
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2,tmp_x3=self.unet2.forward_b(tmp_x2)
+                if(if_half):se_mean2 += torch.mean(tmp_x3.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean2 += torch.mean(tmp_x3, dim=(2, 3),keepdim=True)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)
+                if(if_half):se_mean3 += torch.mean(tmp_x4.float(), dim=(2, 3),keepdim=True).half()
+                else:se_mean3 += torch.mean(tmp_x4, dim=(2, 3),keepdim=True)
+        # print("4x-n_patch=%s,tile_mode=%s" % (n_patch,tile_mode))
+        ###########stage1+state2+state3+stage4+stage_tail
+        res = torch.zeros((n, c, h * 4 - 152, w * 4 - 152),dtype=torch.uint8,device=x.device)
+        for i in range(0,h-38,crop_size[0]):
+            for j in range(0,w-38,crop_size[1]):
+                tmp0,x_crop = self.unet1.forward_a(x[:,:,i:i+crop_size[0]+38,j:j+crop_size[1]+38])
+                x_crop=self.unet1.conv2.seblock.forward_mean(x_crop,se_mean0/n_patch)
+                x_crop=self.unet1.forward_b(tmp0,x_crop)
+                tmp_x1,tmp_x2 = self.unet2.forward_a(x_crop)
+                x_crop = F.pad(x_crop,(-20,-20,-20,-20))
+                tmp_x2=self.unet2.conv2.seblock.forward_mean(tmp_x2,se_mean1/n_patch)
+                tmp_x2, tmp_x3 = self.unet2.forward_b(tmp_x2)
+                tmp_x3=self.unet2.conv3.seblock.forward_mean(tmp_x3,se_mean2/n_patch)
+                tmp_x4=self.unet2.forward_c(tmp_x2,tmp_x3)*alpha
+                tmp_x4=self.unet2.conv4.seblock.forward_mean(tmp_x4,se_mean3/n_patch)
+                x0=self.unet2.forward_d(tmp_x1,tmp_x4)
+                x_crop = torch.add(x0, x_crop)
+                x_crop=self.conv_final(x_crop)
+                x_crop = F.pad(x_crop, (-1, -1, -1, -1))
+                x_crop=self.ps(x_crop)
+                x00_crop=x00[:, :, i:i + h1 - 38, j:j + w1 - 38]
+                _,_,h2,w2=x00_crop.shape
+                x_crop[:,:,:h2*4,:w2*4]+=F.interpolate(x00_crop, scale_factor=4, mode='nearest')
+                if(pro):
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = ((x_crop-0.15) * (255/0.7)).round().clamp_(0, 255).byte()
+                else:
+                    res[:, :, i * 4:i * 4 + h1 * 4 - 152, j * 4:j * 4 + w1 * 4 - 152] = (x_crop*255).round().clamp_(0, 255).byte()
+        #torch.cuda.empty_cache()
+        if(w0!=pw or h0!=ph):res=res[:,:,:h0*4,:w0*4]
+        return res
+class RealWaifuUpScaler(object):
+    def __init__(self,scale,weight_path,half,device):
+        weight = torch.load(weight_path, map_location="cpu")
+        self.pro="pro"in weight
+        if(self.pro):del weight["pro"]
+        self.model=eval("UpCunet%sx"%scale)()
+        if(half==True):self.model=self.model.half().to(device)
+        else:self.model=self.model.to(device)
+        self.model.load_state_dict(weight, strict=True)
+        self.model.eval()
+        self.half=half
+        self.device=device
+
+    def np2tensor(self,np_frame):
+        if(self.pro):
+            if (self.half == False):return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).float() / (255/0.7)+0.15
+            else:return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).half() / (255/0.7)+0.15
+        else:
+            if (self.half == False):return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).float() / 255
+            else:return torch.from_numpy(np.transpose(np_frame, (2, 0, 1))).unsqueeze(0).to(self.device).half() / 255
+
+    def tensor2np(self,tensor):
+        return (np.transpose(tensor.squeeze().cpu().numpy(), (1, 2, 0)))
+
+    def __call__(self, frame,tile_mode,cache_mode,alpha):
+        with torch.no_grad():
+            tensor = self.np2tensor(frame)
+            if(cache_mode==3):
+                result = self.tensor2np(self.model.forward_gap_sync(tensor,tile_mode,alpha,self.pro))
+            elif(cache_mode==2):
+                result = self.tensor2np(self.model.forward_fast_rough(tensor,tile_mode,alpha,self.pro))
+            else:
+                result = self.tensor2np(self.model(tensor,tile_mode,cache_mode,alpha,self.pro))
+        return result
+
+if __name__ == "__main__":
+    ###########inference_img
+    import time, cv2,sys,pdb
+    from time import time as ttime
+    for weight_path, scale in [("weights_v3/up2x-latest-denoise3x.pth", 2),("weights_v3/up3x-latest-denoise3x.pth", 3),("weights_v3/up4x-latest-denoise3x.pth", 4),("weights_pro/pro-denoise3x-up2x.pth", 2),("weights_pro/pro-denoise3x-up3x.pth", 3),]:
+        for tile_mode in [0,5]:
+            for cache_mode in [0,1,2,3]:
+                for alpha in [1]:
+                    weight_name=weight_path.split("/")[-1].split(".")[0]
+                    upscaler2x = RealWaifuUpScaler(scale, weight_path, half=True, device="cuda:0")
+                    input_dir="%s/inputs"%root_path
+                    output_dir="%s/output-dir-all-test"%root_path
+                    os.makedirs(output_dir,exist_ok=True)
+                    for name in os.listdir(input_dir):
+                        print(name)
+                        tmp = name.split(".")
+                        inp_path = os.path.join(input_dir, name)
+                        suffix = tmp[-1]
+                        prefix = ".".join(tmp[:-1])
+                        tmp_path = os.path.join(root_path, "tmp", "%s.%s" % (int(time.time() * 1000000), suffix))
+                        print(inp_path,tmp_path)
+                        #支持中文路径
+                        #os.link(inp_path, tmp_path)#win用硬链接
+                        os.symlink(inp_path, tmp_path)#linux用软链接
+                        frame = cv2.imread(tmp_path)[:, :, [2, 1, 0]]
+                        t0 = ttime()
+                        result = upscaler2x(frame, tile_mode=tile_mode,cache_mode=cache_mode,alpha=alpha)[:, :, ::-1]
+                        t1 = ttime()
+                        print(prefix, "done", t1 - t0,"tile_mode=%s"%tile_mode,cache_mode)
+                        tmp_opt_path = os.path.join(root_path, "tmp", "%s.%s" % (int(time.time() * 1000000), suffix))
+                        cv2.imwrite(tmp_opt_path, result)
+                        n=0
+                        while (1):
+                            if (n == 0):suffix = "_%sx_tile%s_cache%s_alpha%s_%s.png" % (scale, tile_mode, cache_mode, alpha,weight_name)
+                            else:suffix = "_%sx_tile%s_cache%s_alpha%s_%s_%s.png" % (scale, tile_mode, cache_mode, alpha, weight_name,n)
+                            if (os.path.exists(os.path.join(output_dir, prefix + suffix)) == False):break
+                            else:n += 1
+                        final_opt_path=os.path.join(output_dir, prefix + suffix)
+                        os.rename(tmp_opt_path,final_opt_path)
+                        os.remove(tmp_path)

requirements.txt

@@ -0,0 +1,8 @@
+fastapi==0.115.12
+uvicorn[standard]==0.30.6
+python-multipart==0.0.9
+Jinja2==3.1.4
+itsdangerous==2.2.0
+requests==2.32.3
+Pillow==10.4.0
+numpy==1.26.4

weights/up2x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6cfe3b23687915d08ba96010f25198d9cfe8a683aa4131f1acf7eaa58ee1de93
+size 5147249

weights/up2x-latest-denoise1x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2e783c39da6a6394fbc250fdd069c55eaedc43971c4f2405322f18949ce38573
+size 5147249

weights/up2x-latest-denoise2x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8188b3faef4258cf748c59360cbc8086ebedf4a63eb9d5d6637d45f819d32496
+size 5147249

weights/up2x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0a14739f3f5fcbd74ec3ce2806d13a47916c916b20afe4a39d95f6df4ca6abd8
+size 5147249

weights/up2x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f491f9ecf6964ead9f3a36bf03e83527f32c6a341b683f7378ac6c1e2a5f0d16
+size 5147249

weights/up3x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6ea5fd20380413beb2701182483fd80c2e86f3b3f08053eb3df4975184aefe3
+size 5154161

weights/up3x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39f1e6e90d50e5528a63f4ba1866bad23365a737cbea22a80769b2ec4c1c3285
+size 5154161

weights/up3x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:763f0a87e70d744673f1a41db5396d5f334d22de97fff68ffc40deb91404a584
+size 5154161

weights/up4x-latest-conservative.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a8c8185def699b0883662a02df0ef2e6db3b0275170b6cc0d28089b64b273427
+size 5636403

weights/up4x-latest-denoise3x.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42bd8fcdae37c12c5b25ed59625266bfa65780071a8d38192d83756cb85e98dd
+size 5636403

weights/up4x-latest-no-denoise.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:aaf3ef78a488cce5d3842154925eb70ff8423b8298e2cd189ec66eb7f6f66fae
+size 5636403