logo

Transformer超分显存优化与部署

作者:菠萝爱吃肉2026.11.18 11:34浏览量:0

简介:本文面向需要落地Transformer超分的开发者,提供SwinIR训练、LR退化脚本、显存回退、PSNR口径、ONNX导出、分块推理与部署验收的完整流程。包含可运行代码、排查表和复现建议,帮助读者跑通从数据构造到服务上线的闭环。

一、教程目标:Transformer超分怎么做,显存回退怎么选?

本文面向需要落地Transformer超分辨率(Super-Resolution,SR)的开发者、算法工程师和技术负责人,围绕SwinIR这类“浅层卷积 + 深层自注意力 + 上采样重建”的模型,给出从环境搭建、数据构造、训练调优、显存优化、ONNX导出到推理部署的完整链路。

开工前先对齐几个高频问题:

  • Transformer超分到底怎么做?
    典型流程是:浅层卷积提取基础特征,深层窗口注意力建立局部与跨窗口依赖,最后通过上采样模块重建高分辨率图像。本文给出可运行的训练与导出骨架。

  • 放大倍数怎么选?
    2x/3x更适合温和增强;4x及以上更依赖注意力模块恢复纹理。倍数越高,显存和算力压力越大。本文基线为4x。

  • SwinIR训练显存不足怎么办?
    优先降低batch size并配合梯度累积,其次启用混合精度;仍不足时再降低embed_dim或window size。upscale是业务需求,不宜为省显存降低。

  • ONNX部署要注意什么?
    需要关注动态shape、窗口对齐、分块推理、量化精度、单张延迟、P95/P99延迟以及异常回退。

  • 生成图有伪影或过度平滑怎么排查?
    常见原因是退化模拟与真实场景不匹配,或感知损失权重过高。建议先检查LR构造流程,再调整损失函数。

本文核心指标包括:PSNR(峰值信噪比,越高质量越好)、SSIM(结构相似性,越接近1越好)、LPIPS(学习感知图像块相似度,越低表示感知差异越小)。

二、适用边界与前置准备

适用读者包括:有编程与深度学习基础的开发者、算法工程师,以及评估画质增强可行性的技术负责人。

以下场景不建议直接套用本文方案:

  • 极低延迟的实时交互场景。注意力模型单张推理常达数十至百余毫秒,需先蒸馏、量化或改用轻量CNN后再评估。
  • 单卡小显存且没有回退空间的环境。
  • 手机、IoT等低算力端侧部署。此类场景建议改用轻量CNN超分或专用推理芯片方案。

硬件方面,建议使用支持CUDA的GPU;4x基线建议至少16GB显存。软件方面,建议固定版本矩阵,并保留升级回滚方案,避免驱动、CUDA、PyTorch和算子库不匹配。

组件 推荐版本
NVIDIA驱动 ≥525
CUDA 12.1
PyTorch 2.1.0+cu121
Python 3.10
OpenCV 4.8.1
官方镜像 pytorch/pytorch:2.1.0-cuda12.1-cudnn8

数据合规方面需提前确认:

  • 高分辨率训练原图应具备合法授权,必要时确认商用许可。
  • 若数据涉及人脸、车牌、身份证件等敏感内容,应提前脱敏。
  • 明确业务图片的使用边界、留存周期与删除机制,避免后续合规风险。

三、实施步骤

步骤一:搭建并验证计算环境

建议先用固定版本锁定环境,再运行最小验证脚本。

  1. import torch
  2. print("torch:", torch.__version__, "cuda_available:", torch.cuda.is_available())
  3. print("device:", torch.cuda.get_device_name(0))
  4. x = torch.randn(1024, 1024, device="cuda")
  5. y = x @ x.t()
  6. print("matmul ok:", tuple(y.shape), float(y.sum().item()))

看到cuda_available: True且无报错,即可进入下一步。

步骤二:构建HR/LR训练数据与manifest

超分任务使用成对样本:HR为标签,LR由HR退化得到。代码骨架默认读取以下目录结构:

  1. data/
  2. train/hr/*.png train/lr/*.png train/manifest.txt
  3. val/hr/*.png val/lr/*.png val/manifest.txt
  4. test/hr/*.png test/lr/*.png test/manifest.txt

下面给出可运行的退化脚本。它会完成随机划分、HR复制、随机高斯模糊、按scale下采样、噪声、JPEG压缩,并生成manifest。训练、验证、测试默认按80/10/10划分,测试集固定作为回归基准。

  1. # make_lr.py
  2. import os
  3. import glob
  4. import random
  5. import argparse
  6. import cv2
  7. import numpy as np
  8. def degrade(img, scale):
  9. h, w = img.shape[:2]
  10. sigma = random.uniform(0.2, 1.5)
  11. img = cv2.GaussianBlur(img, (0, 0), sigmaX=sigma, sigmaY=sigma)
  12. lr = cv2.resize(
  13. img,
  14. (max(1, w // scale), max(1, h // scale)),
  15. interpolation=cv2.INTER_AREA
  16. )
  17. if random.random() < 0.8:
  18. noise = random.randint(0, 15)
  19. lr = lr.astype(np.float32)
  20. lr = lr + np.random.normal(0.0, noise, lr.shape).astype(np.float32)
  21. lr = np.clip(lr, 0, 255).astype(np.uint8)
  22. quality = random.randint(40, 95)
  23. ok, buf = cv2.imencode(".jpg", lr, [int(cv2.IMWRITE_JPEG_QUALITY), quality])
  24. if not ok:
  25. raise RuntimeError("JPEG encode failed")
  26. lr = cv2.imdecode(buf, cv2.IMREAD_COLOR)
  27. return lr
  28. def main():
  29. parser = argparse.ArgumentParser()
  30. parser.add_argument("--hr", required=True, help="高分辨率原图目录")
  31. parser.add_argument("--out", required=True, help="输出 data 根目录")
  32. parser.add_argument("--scale", type=int, default=4)
  33. parser.add_argument("--seed", type=int, default=2025)
  34. args = parser.parse_args()
  35. random.seed(args.seed)
  36. np.random.seed(args.seed)
  37. hr_paths = sorted(glob.glob(os.path.join(args.hr, "*.png")))
  38. if not hr_paths:
  39. hr_paths = sorted(glob.glob(os.path.join(args.hr, "*.jpg")))
  40. if not hr_paths:
  41. raise RuntimeError("未找到 HR 图像")
  42. rng = np.random.RandomState(args.seed)
  43. idx = rng.permutation(len(hr_paths))
  44. n = len(hr_paths)
  45. n_train = int(n * 0.8)
  46. n_val = int(n * 0.1)
  47. splits = {
  48. "train": idx[:n_train],
  49. "val": idx[n_train:n_train + n_val],
  50. "test": idx[n_train + n_val:]
  51. }
  52. for split, ids in splits.items():
  53. hr_dir = os.path.join(args.out, split, "hr")
  54. lr_dir = os.path.join(args.out, split, "lr")
  55. os.makedirs(hr_dir, exist_ok=True)
  56. os.makedirs(lr_dir, exist_ok=True)
  57. manifest = []
  58. for i in ids:
  59. hr_path = hr_paths[int(i)]
  60. name = os.path.splitext(os.path.basename(hr_path))[0] + ".png"
  61. hr_out = os.path.join(hr_dir, name)
  62. lr_out = os.path.join(lr_dir, name)
  63. hr = cv2.imread(hr_path, cv2.IMREAD_COLOR)
  64. if hr is None:
  65. raise RuntimeError(f"读取失败: {hr_path}")
  66. cv2.imwrite(hr_out, hr)
  67. lr = degrade(hr, args.scale)
  68. cv2.imwrite(lr_out, lr)
  69. manifest.append(f"{hr_out} {lr_out}")
  70. with open(os.path.join(args.out, split, "manifest.txt"), "w", encoding="utf-8") as f:
  71. f.write("\n".join(manifest))
  72. if __name__ == "__main__":
  73. main()

运行示例:

  1. python make_lr.py --hr raw_hr --out data --scale 4 --seed 2025

预处理时统一使用hr_patch=64作为HR块尺寸,对应LR块尺寸为16。像素归一化到[0,1]。归一化参数只用训练集统计,val/test复用同一套参数,避免数据泄漏。

步骤三:模型结构与显存回退配置

Transformer超分通常采用三段式结构:

  1. 浅层特征提取;
  2. 深层注意力建模;
  3. 上采样重建。

下面给出4x基线和显存不足时的回退配置。这里明确使用depths=[4]*4,避免“4×4”造成歧义。

参数 4x基线 显存不足回退
upscale 4 4,业务需求不降低
window 8 6
depths depths=[6]*6,共36层 depths=[4]*4,共16层
embed_dim 180 120
num_heads [6]*6 [4]*4
batch_size 8 4
accum 1 2
lr 2e-4 2e-4
epochs 800 300

需要强调:层数增加近似线性增加显存与算力;窗口内注意力的显存与算力约随窗口边长的平方增长。因此当OOM时,优先降低batch并加入梯度累积,其次降低embed_dim或window,最后才考虑减少depth或num_heads。

损失函数建议先跑通L1,确认训练稳定后,再按需加入感知损失或对抗损失,以提升主观画质。

步骤四:训练调优与调度口径

训练策略建议:

  • 优化器:AdamW;
  • 学习率:2e-4;
  • 调度:warmup + 余弦退火;
  • 混合精度:AMP;
  • 梯度裁剪:1.0;
  • 梯度累积:显存不足时使用;
  • 验证:每轮在固定验证集上计算PSNR/SSIM;
  • 早停:验证指标长期不升时早停或降低学习率;
  • 小规模联调:先在1k张缩略数据上跑通,再放大到全量。

特别注意:warmup和total_steps应按优化器更新步数计算,而不是简单按len(train_loader) * epochs。如果梯度累积为accum,每个epoch的优化器更新步数应约为:

  1. updates_per_epoch = ceil(len(train_loader) / accum)
  2. total_steps = updates_per_epoch * epochs

步骤五:推理与部署

生产部署建议优先导出ONNX。ONNX便于跨框架加载和算子加速,但量化与加速效果取决于硬件与精度要求,须以实测PSNR与延迟验收。

本步骤至少包含四件事:

  1. 使用ONNX Runtime加载模型,并完成RGB归一化、窗口对齐padding、输出裁剪和uint8缩放;
  2. 对超大图使用按scale对齐的分块推理,即tile + overlap;
  3. 建立单张延迟、QPS、P95/P99延迟和GPU显存占用口径;
  4. 量化或蒸馏前后对比PSNR/SSIM,确认精度可接受。

服务层建议增加健康检查、并发限制、超时与失败回退。例如可用FastAPI包装:

  1. # 服务层伪代码,示意即可
  2. from fastapi import FastAPI, UploadFile
  3. import asyncio
  4. app = FastAPI()
  5. limit = asyncio.Semaphore(4)
  6. @app.get("/health")
  7. async def health():
  8. return {"ok": True}
  9. @app.post("/sr")
  10. async def sr(file: UploadFile):
  11. async with limit:
  12. # 实际项目中用 cv2.imdecode 解码,并在线程池执行 ONNX 推理
  13. # out = await asyncio.to_thread(onnx_sr_rgb, img)
  14. return {"ok": True}

四、可运行代码骨架:训练、导出、ONNX分块推理

以下代码以PyTorch 2.1 + ONNX + ONNX Runtime为目标环境。运行前请先执行make_lr.py生成data/train、data/val、data/test。

  1. # 依赖安装:
  2. # pip install torch==2.1.0 torchvision==0.16.0 numpy==1.26.4 opencv-python==4.8.1.76
  3. # pip install onnx==1.16.0 onnxruntime-gpu==1.17.1 scikit-image==0.22.0 basicsr
  4. import os
  5. import math
  6. import time
  7. import glob
  8. import cv2
  9. import numpy as np
  10. import torch
  11. import torch.nn.functional as F
  12. from torch.utils.data import Dataset, DataLoader
  13. from basicsr.archs.swinir_arch import SwinIR
  14. from skimage.metrics import structural_similarity
  15. # 导出模型的 window_size 必须与训练时一致。
  16. # 若训练 window=8,请保持 EXPORT_WINDOW=8;若训练 window=6,请同步改为6。
  17. EXPORT_WINDOW = 8
  18. def rgb_to_y(img: np.ndarray) -> np.ndarray:
  19. """RGB [0,1] 转 Y 通道,返回 0-255 的 full-range Y。
  20. 该口径下 PSNR 峰值统一使用 255。
  21. """
  22. r, g, b = img[..., 0], img[..., 1], img[..., 2]
  23. return (0.299 * r + 0.587 * g + 0.114 * b) * 255.0
  24. class PairedSR(Dataset):
  25. """成对超分数据:HR标签,LR由HR退化得到。"""
  26. def __init__(self, root: str, split: str, scale: int = 4, hr_patch: int = 64, train: bool = True):
  27. self.hr_paths = []
  28. self.lr_paths = []
  29. hr_dir = os.path.join(root, split, "hr")
  30. lr_dir = os.path.join(root, split, "lr")
  31. manifest = os.path.join(root, split, "manifest.txt")
  32. if os.path.exists(manifest):
  33. with open(manifest, "r", encoding="utf-8") as f:
  34. for line in f:
  35. parts = line.strip().split()
  36. if len(parts) == 2:
  37. self.hr_paths.append(parts[0])
  38. self.lr_paths.append(parts[1])
  39. else:
  40. self.hr_paths = sorted(glob.glob(os.path.join(hr_dir, "*.png")))
  41. self.lr_paths = sorted(glob.glob(os.path.join(lr_dir, "*.png")))
  42. assert len(self.hr_paths) == len(self.lr_paths), "HR/LR 文件数量不一致"
  43. self.scale = scale
  44. self.hr_patch = hr_patch
  45. self.lr_patch = hr_patch // scale
  46. self.train = train
  47. def __len__(self):
  48. return len(self.hr_paths)
  49. def __getitem__(self, idx):
  50. hr_bgr = cv2.imread(self.hr_paths[idx], cv2.IMREAD_COLOR)
  51. lr_bgr = cv2.imread(self.lr_paths[idx], cv2.IMREAD_COLOR)
  52. assert hr_bgr is not None and lr_bgr is not None
  53. hr = cv2.cvtColor(hr_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
  54. lr = cv2.cvtColor(lr_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
  55. if self.train:
  56. h, w, _ = hr.shape
  57. if h < self.hr_patch or w < self.hr_patch:
  58. raise ValueError(f"HR 尺寸太小: {hr.shape},训练集应使用不小于 hr_patch 的图。")
  59. top = np.random.randint(0, h - self.hr_patch + 1)
  60. left = np.random.randint(0, w - self.hr_patch + 1)
  61. hr = hr[top:top + self.hr_patch, left:left + self.hr_patch]
  62. lr = lr[
  63. top // self.scale : (top + self.hr_patch) // self.scale,
  64. left // self.scale : (left + self.hr_patch) // self.scale
  65. ]
  66. hr = torch.from_numpy(hr).permute(2, 0, 1)
  67. lr = torch.from_numpy(lr).permute(2, 0, 1)
  68. return lr, hr
  69. def build_loader(root: str, split: str, batch_size: int = 8, train: bool = True):
  70. return DataLoader(
  71. PairedSR(root, split, scale=4, hr_patch=64, train=train),
  72. batch_size=batch_size,
  73. shuffle=train,
  74. num_workers=4,
  75. pin_memory=True,
  76. drop_last=train
  77. )
  78. @torch.no_grad()
  79. def validate(model, loader):
  80. model.eval()
  81. psnrs, ssims = [], []
  82. for lr, hr in loader:
  83. lr = lr.cuda()
  84. sr = model(lr).clamp(0, 1).float().cpu()
  85. hr = hr.cpu()
  86. for i in range(sr.shape[0]):
  87. sr_np = sr[i].permute(1, 2, 0).numpy()
  88. hr_np = hr[i].permute(1, 2, 0).numpy()
  89. y_sr = rgb_to_y(sr_np)
  90. y_hr = rgb_to_y(hr_np)
  91. mse = float(np.mean((y_sr - y_hr) ** 2))
  92. # Y为0-255 full-range,峰值使用255。
  93. psnr = 10.0 * math.log10(255.0 ** 2 / (mse + 1e-12))
  94. psnrs.append(psnr)
  95. ssims.append(
  96. structural_similarity(
  97. hr_np,
  98. sr_np,
  99. channel_axis=-1,
  100. data_range=1.0
  101. )
  102. )
  103. return float(np.mean(psnrs)), float(np.mean(ssims))
  104. def train_and_export():
  105. device = "cuda"
  106. train_loader = build_loader("data", "train", batch_size=8, train=True)
  107. val_loader = build_loader("data", "val", batch_size=1, train=False)
  108. model = SwinIR(
  109. upscale=4,
  110. window_size=8,
  111. depths=[6] * 6,
  112. embed_dim=180,
  113. num_heads=[6] * 6
  114. ).to(device)
  115. opt = torch.optim.AdamW(model.parameters(), lr=2e-4, betas=(0.9, 0.99))
  116. epochs = 800
  117. accum = 1 # 显存不足时可改为2,并同步确认调度步数
  118. # 调度步数按优化器更新步数计算,而不是原始batch步数。
  119. updates_per_epoch = math.ceil(len(train_loader) / accum)
  120. total_steps = updates_per_epoch * epochs
  121. warmup_steps = max(1, int(0.05 * total_steps))
  122. def lr_lambda(step):
  123. if step < warmup_steps:
  124. return float(step) / max(1, warmup_steps)
  125. progress = (step - warmup_steps) / max(1, total_steps - warmup_steps)
  126. return 0.5 * (1.0 + math.cos(math.pi * progress))
  127. sched = torch.optim.lr_scheduler.LambdaLR(opt, lr_lambda)
  128. scaler = torch.cuda.amp.GradScaler()
  129. best_psnr = -1.0
  130. best_epoch = -1
  131. bad_epochs = 0
  132. patience = 120
  133. for epoch in range(epochs):
  134. model.train()
  135. opt.zero_grad(set_to_none=True)
  136. for i, (lr, hr) in enumerate(train_loader):
  137. lr = lr.to(device, non_blocking=True)
  138. hr = hr.to(device, non_blocking=True)
  139. with torch.cuda.amp.autocast():
  140. sr = model(lr)
  141. loss = F.l1_loss(sr.float(), hr)
  142. scaler.scale(loss / accum).backward()
  143. if (i + 1) % accum == 0 or (i + 1) == len(train_loader):
  144. scaler.unscale_(opt)
  145. torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
  146. scaler.step(opt)
  147. scaler.update()
  148. opt.zero_grad(set_to_none=True)
  149. sched.step()
  150. psnr, ssim = validate(model, val_loader)
  151. print(f"epoch={epoch + 1}, psnr={psnr:.3f}, ssim={ssim:.4f}")
  152. if psnr > best_psnr:
  153. best_psnr = psnr
  154. best_epoch = epoch + 1
  155. bad_epochs = 0
  156. torch.save(
  157. {
  158. "model": model.state_dict(),
  159. "cfg": "cfg_4x.yaml",
  160. "psnr": psnr,
  161. "ssim": ssim
  162. },
  163. "sr_4x_best.pt"
  164. )
  165. else:
  166. bad_epochs += 1
  167. if (epoch + 1) % 50 == 0:
  168. torch.save(
  169. {
  170. "model": model.state_dict(),
  171. "cfg": "cfg_4x.yaml",
  172. "epoch": epoch + 1
  173. },
  174. "sr_4x_epoch.pt"
  175. )
  176. if bad_epochs >= patience:
  177. print(f"early stop at epoch={epoch + 1}, best_epoch={best_epoch}")
  178. break
  179. # 加载最佳权重后再导出
  180. ckpt = torch.load("sr_4x_best.pt", map_location=device)
  181. model.load_state_dict(ckpt["model"])
  182. model.eval()
  183. torch.save(
  184. {
  185. "model": model.state_dict(),
  186. "cfg": "cfg_4x.yaml"
  187. },
  188. "sr_4x.pt"
  189. )
  190. dummy = torch.randn(1, 3, 64, 64, device=device)
  191. torch.onnx.export(
  192. model,
  193. dummy,
  194. "sr_4x.onnx",
  195. input_names=["lr"],
  196. output_names=["sr"],
  197. dynamic_axes={
  198. "lr": {2: "H", 3: "W"},
  199. "sr": {2: "H_out", 3: "W_out"}
  200. },
  201. opset_version=17
  202. )
  203. # ------------------------- ONNX Runtime 推理 -------------------------
  204. _ORT_SESSION = None
  205. def get_ort_session(path="sr_4x.onnx"):
  206. global _ORT_SESSION
  207. if _ORT_SESSION is None:
  208. import onnxruntime as ort
  209. providers = []
  210. for p in ["CUDAExecutionProvider", "CPUExecutionProvider"]:
  211. if p in ort.get_available_providers():
  212. providers.append(p)
  213. if not providers:
  214. providers = ["CPUExecutionProvider"]
  215. _ORT_SESSION = ort.InferenceSession(path, providers=providers)
  216. return _ORT_SESSION
  217. def pad_to_multiple(img: np.ndarray, multiple: int):
  218. """按模型window_size对齐,返回padding后的图、pad_h、pad_w。"""
  219. h, w = img.shape[:2]
  220. pad_h = (multiple - h % multiple) % multiple
  221. pad_w = (multiple - w % multiple) % multiple
  222. if pad_h == 0 and pad_w == 0:
  223. return img, 0, 0
  224. padded = np.pad(img, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
  225. return padded, pad_h, pad_w
  226. def onnx_sr_rgb(lr_rgb: np.ndarray, scale: int = 4) -> np.ndarray:
  227. """单图推理,输入RGB float32 [0,1],输出RGB uint8 [0,255]。
  228. 对非window整数倍输入自动按EXPORT_WINDOW对齐,并裁剪回原比例。
  229. """
  230. x = np.asarray(lr_rgb, dtype=np.float32)
  231. x = np.clip(x, 0.0, 1.0)
  232. h, w = x.shape[:2]
  233. x_pad, _, _ = pad_to_multiple(x, EXPORT_WINDOW)
  234. inp = x_pad.transpose(2, 0, 1)[None]
  235. y = get_ort_session().run(None, {"lr": inp})[0][0]
  236. y = y.transpose(1, 2, 0)
  237. # 去掉因window对齐引入的多余输出
  238. y = y[:h * scale, :w * scale]
  239. y = np.clip(y, 0.0, 1.0)
  240. return (y * 255.0).round().astype(np.uint8)
  241. def tiled_onnx_sr(img_bgr: np.ndarray, scale: int = 4, tile: int = 256, overlap: int = 32) -> np.ndarray:
  242. """按scale对齐的分块推理,适用于大图推理显存不足或输出尺寸过大场景。"""
  243. if tile < EXPORT_WINDOW:
  244. tile = EXPORT_WINDOW
  245. if overlap >= tile:
  246. overlap = tile // 2
  247. img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
  248. h, w, _ = img_rgb.shape
  249. out = np.zeros((h * scale, w * scale, 3), dtype=np.float32)
  250. weight = np.zeros((h * scale, w * scale, 1), dtype=np.float32)
  251. step = max(1, tile - overlap)
  252. xs = list(range(0, max(1, w - tile + 1), step))
  253. if not xs or xs[-1] != max(0, w - tile):
  254. xs.append(max(0, w - tile))
  255. ys = list(range(0, max(1, h - tile + 1), step))
  256. if not ys or ys[-1] != max(0, h - tile):
  257. ys.append(max(0, h - tile))
  258. for y in ys:
  259. for x in xs:
  260. patch = img_rgb[y:y + tile, x:x + tile]
  261. ph, pw = patch.shape[:2]
  262. # 按模型window_size对齐,而不是固定8
  263. patch_pad, _, _ = pad_to_multiple(patch, EXPORT_WINDOW)
  264. inp = patch_pad.transpose(2, 0, 1)[None]
  265. out_patch = get_ort_session().run(None, {"lr": inp})[0][0]
  266. out_patch = out_patch.transpose(1, 2, 0)
  267. out_patch = out_patch[:ph * scale, :pw * scale]
  268. out_patch = np.clip(out_patch, 0.0, 1.0)
  269. y0, x0 = y * scale, x * scale
  270. out[y0:y0 + ph * scale, x0:x0 + pw * scale] += out_patch
  271. weight[y0:y0 + ph * scale, x0:x0 + pw * scale] += 1.0
  272. out = out / np.maximum(weight, 1e-6)
  273. out = (out * 255.0).round().astype(np.uint8)
  274. return cv2.cvtColor(out, cv2.COLOR_RGB2BGR)
  275. def bench_single_image(img_bgr: np.ndarray, repeat: int = 10):
  276. tiled_onnx_sr(img_bgr)
  277. start = time.perf_counter()
  278. for _ in range(repeat):
  279. tiled_onnx_sr(img_bgr)
  280. cost = (time.perf_counter() - start) / repeat * 1000.0
  281. return cost
  282. if __name__ == "__main__":
  283. # 前置:先运行 make_lr.py 生成 data/train、data/val、data/test
  284. train_and_export()
  285. # 推理示例
  286. # img = cv2.imread("data/test/lr/example.png")
  287. # out = tiled_onnx_sr(img, scale=4, tile=256, overlap=32)
  288. # cv2.imwrite("test_sr.png", out)
  289. # print("single image latency ms:", bench_single_image(img, repeat=10))

推理输入输出约定如下:

  • 输入lr:[1,3,H,W],float32,范围[0,1];
  • 输出sr:[1,3,scale×H,scale×W],范围[0,1];
  • 若输入不是window size整数倍,推理前应按模型window_size对齐padding,输出后再裁剪回原尺寸比例;
  • 量化、剪枝、蒸馏前,先在固定测试集上记录FP32基线指标。

部署层面建议将模型文件放入对象存储,服务容器化后接入负载均衡与弹性伸缩,并统一身份认证与最小权限访问。对并发压测时,建议同时记录单张延迟、QPS、P95/P99延迟和GPU显存占用。

五、结果验证与基线对比

示例测量条件:固定测试集1000张;GPU为16GB显存NVIDIA GPU;输入LR为128×128,输出HR为512×512;batch=1;精度FP16;框架为PyTorch 2.1 + ONNX Runtime 1.17。

指标 测量口径 Bicubic基线 4x基线(示例)
PSNR↑ Y通道,Y为0-255 full-range,峰值255,dB 26.1 28.4
SSIM↑ 全通道,data_range=1.0 0.79 0.86
LPIPS↓ 感知距离 0.35 0.21
延迟 batch=1,LR 128×128→HR 512×512,FP16 — ~120 ms/张
显存 推理,FP16 — 3.2 GB

注意:表中数值为示例值,仅用于说明测量方式,不代表固定性能;不同数据集、GPU型号、输入尺寸、样本量、框架版本都会影响结果,请以自行复测为准。

复现建议:

  1. # 1. 构造数据,固定随机种子
  2. PYTHONHASHSEED=0 python make_lr.py --hr raw_hr --out data --scale 4 --seed 2025
  3. # 2. 训练并导出ONNX
  4. PYTHONHASHSEED=0 python train_sr.py
  5. # 3. 推理自检
  6. PYTHONHASHSEED=0 python bench_sr.py

如果原实现使用16-235有限范围Y通道,请将PSNR峰值改为235,或先将Y归一化到0-255后再计算。本文代码采用0-255 full-range Y,因此峰值统一为255。

六、常见问题排查表

现象 可能原因 检查 处理与回退
OOM(训练) batch/window过大 nvidia-smi 降batch + 梯度累积、混合精度
Loss震荡/不收敛 lr过大/归一化错误 查看loss曲线 lr降到1e-4,先用小模型验证
伪影/过度平滑 退化不匹配/感知损失权重高 对比退化与真实图 调整退化模拟,降感知损失权重
ONNX导出报错 自定义算子或fused attention不兼容 onnx.checker 改纯PyTorch注意力实现,或尝试torch.onnx.dynamo_export
推理显存不足 大图/批处理过大 显存监控 分块推理,tile + overlap;仅用于部署推理
推理延迟高 overlap过大/未批处理/FP32 单张延迟与并发压测 调overlap、批处理、FP16/INT8、剪枝、蒸馏、TensorRT
ONNX输出尺寸异常 动态shape或窗口未对齐 检查输入尺寸与EXPORT_WINDOW 按window_size padding,并裁剪回原比例
分块拼接有接缝 overlap太小或权重平均不足 对比重叠区域 增大overlap,或改用更平滑的权重图

建议增加推理前自检:

  1. def check_onnx_inference():
  2. img = cv2.imread("data/test/lr/example.png")
  3. out = tiled_onnx_sr(img, scale=4, tile=256, overlap=32)
  4. assert out.shape[0] == img.shape[0] * 4
  5. assert out.shape[1] == img.shape[1] * 4
  6. print("ONNX inference shape check ok")

七、总结

本文给出了一条可落地的Transformer超分链路:从环境版本矩阵、LR退化脚本、manifest构造、可复现配置表,到训练、显存优化、ONNX导出、ONNX Runtime推理、分块推理与部署验证。关键要点包括:

  • 数据退化要贴近真实场景,并保持训练、验证、测试流程一致;
  • 配置要匹配显存预算,显存不足优先降batch、加梯度累积、启用混合精度;
  • 学习率调度要按优化器更新步数计算,避免梯度累积导致调度失真;
  • PSNR计算要统一Y通道口径,全文使用0-255 full-range Y,峰值255;
  • 推理分块padding要按模型window_size对齐,而不是固定8;
  • 推理延迟优化不能只看理论加速,必须用PSNR/SSIM/LPIPS和延迟压测共同验收;
  • 量化、剪枝、蒸馏前必须先在固定测试集上建立基线。

掌握以上内容后,可继续深入注意力轻量化、模型压缩蒸馏,以及将超分能力自动化集成到业务流水线中。

发表评论

活动