first commit

.gitattributes

@@ -33,8 +33,9 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.axmodel filter=lfs diff=lfs merge=lfs -text
-*.mp4 filter=lfs diff=lfs merge=lfs -text
 *.png filter=lfs diff=lfs merge=lfs -text
+*.PNG filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
 *.jpg filter=lfs diff=lfs merge=lfs -text
+*.axmodel filter=lfs diff=lfs merge=lfs -text
+*.gif filter=lfs diff=lfs merge=lfs -text

DnCNN/model_convert/DnCNN.json

@@ -0,0 +1,58 @@
+{
+  "input": "./dncnn_color_blind_416x416_sim.onnx",
+  "output_dir": "./DnCNN",
+  "output_name": "dncnn_color_blind_416x416_sim.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./BSD.tar.gz",
+        "calibration_size": 32,
+        "calibration_mean": [0.0, 0.0, 0.0],
+        "calibration_std": [255.0, 255.0, 255.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    // "enable_smooth_quant": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cuda:1",
+    // "layer_configs": [
+    //   {
+    //     "start_tensor_names": ["DEFAULT"],
+    //     "end_tensor_names": ["DEFAULT"],
+    //     "data_type": "U16"
+    //   }
+    // ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+    // {
+    //   "tensor_name": "input",
+    //   "tensor_format": "RGB",
+    //   "tensor_layout": "NCHW",
+    //   "src_format": "YUV420SP",
+    //   "src_layout": "NHWC",
+    //   "src_dtype": "U8",
+    //   "csc_mode": "FullRange",
+    //   "csc_mat": [1.164, 0, 1.596, -222.912, 1.164, -0.392, -0.813, 135.616, 1.164, 2.017, 0, -276.8]
+    // }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

DnCNN/model_convert/axmodel/dncnn_color_blind_416x416_sim.axmodel

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

DnCNN/python/axmodel_infer.py

@@ -0,0 +1,150 @@
+#!/usr/bin/env python3
+import os
+import cv2
+import numpy as np
+import axengine as axe
+
+# ============================================================
+# 默认参数（可按需修改）
+# ============================================================
+AXMODEL_PATH = "dncnn_color_blind_416x416_sim.axmodel"
+OUTPUT_DIR = "./"
+# AX 量化模型输入格式: "float32" 或 "uint8"，取决于编译时的量化配置
+INPUT_DTYPE = "uint8"           # 量化模型通常为 uint8；float 模型设为 "float32"
+NOISE_SIGMA = 25               # 对原图施加的 AWGN 噪声强度（uint8 尺度，设为 0 则不加噪）
+
+# ============================================================
+
+
+def load_image(img_path):
+    """读取图像，返回 BGR uint8 原始图"""
+    img_bgr = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+    if img_bgr is None:
+        raise FileNotFoundError(f"无法读取图像: {img_path}")
+    if img_bgr.ndim == 2:
+        img_bgr = cv2.cvtColor(img_bgr, cv2.COLOR_GRAY2BGR)
+    return img_bgr
+
+
+def add_awgn(img_bgr, sigma):
+    """对 BGR uint8 图像施加 AWGN，返回加噪后的 BGR uint8 图像"""
+    noise = np.random.randn(*img_bgr.shape).astype(np.float32) * sigma
+    noisy = img_bgr.astype(np.float32) + noise
+    noisy = np.clip(noisy, 0, 255).astype(np.uint8)
+    return noisy
+
+
+def preprocess(img_bgr, model_h, model_w):
+    """
+    预处理: BGR->RGB, resize to model size, 按 INPUT_DTYPE 做归一化或保持 uint8
+    返回: 模型输入张量, 原始尺寸 (h, w)
+    """
+    orig_h, orig_w = img_bgr.shape[:2]
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    img_resized = cv2.resize(img_rgb, (model_w, model_h), interpolation=cv2.INTER_LINEAR)
+
+    if INPUT_DTYPE == "float32":
+        img_float = img_resized.astype(np.float32) / 255.0
+        tensor = np.transpose(img_float, (2, 0, 1))[np.newaxis, ...].astype(np.float32)
+    else:
+        tensor = np.transpose(img_resized, (2, 0, 1))[np.newaxis, ...].astype(np.uint8)
+    return tensor, (orig_h, orig_w)
+
+
+def postprocess(tensor, orig_h, orig_w):
+    """
+    后处理: squeeze batch, CHW->HWC, clip, uint8, resize 回原始尺寸
+    返回: BGR uint8 图像
+    """
+    if tensor.dtype == np.uint8:
+        arr = np.squeeze(tensor, axis=0)
+        arr = np.transpose(arr, (1, 2, 0))
+        arr_uint = arr
+    else:
+        arr = np.clip(np.squeeze(tensor, axis=0), 0.0, 1.0)
+        arr = np.transpose(arr, (1, 2, 0))
+        arr_uint = (arr * 255.0).round().astype(np.uint8)
+    arr_uint = cv2.resize(arr_uint, (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)
+    result_bgr = cv2.cvtColor(arr_uint, cv2.COLOR_RGB2BGR)
+    return result_bgr
+
+
+def make_concat(original_bgr, noisy_bgr, result_bgr,
+                label_left="Original", label_mid="Noisy", label_right="DnCNN AXModel"):
+    """左中右拼接原图、加噪图与结果图，并添加顶部标注"""
+    imgs = [original_bgr, noisy_bgr, result_bgr]
+    labels = [label_left, label_mid, label_right]
+    hs = [im.shape[0] for im in imgs]
+    h = max(hs)
+
+    resized = []
+    for im in imgs:
+        hh, ww = im.shape[:2]
+        if hh != h:
+            im = cv2.resize(im, (int(ww * h / hh), h), interpolation=cv2.INTER_LINEAR)
+        resized.append(im)
+
+    ws = [im.shape[1] for im in resized]
+    total_w = sum(ws)
+    label_h = max(30, h // 25)
+    canvas = np.full((h + label_h, total_w, 3), 255, dtype=np.uint8)
+
+    x = 0
+    for idx, im in enumerate(resized):
+        canvas[label_h:, x:x + ws[idx]] = im
+        x += ws[idx]
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = label_h / 30.0
+    thickness = max(1, int(font_scale))
+    color = (0, 0, 0)
+
+    x = 0
+    for idx, (label, w) in enumerate(zip(labels, ws)):
+        (tw, th), _ = cv2.getTextSize(label, font, font_scale, thickness)
+        cv2.putText(canvas, label, (x + w // 2 - tw // 2, label_h - (label_h - th) // 2),
+                    font, font_scale, color, thickness, cv2.LINE_AA)
+        x += w
+
+    return canvas
+
+
+def main():
+    img_path = './3096.png'
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # ---- 加载 AX 模型 ----
+    session = axe.InferenceSession(AXMODEL_PATH, providers=["AxEngineExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    _, _, model_h, model_w = session.get_inputs()[0].shape
+
+    # ---- 读取原图 ----
+    img_bgr = load_image(img_path)
+
+    # ---- 加噪 ----
+    if NOISE_SIGMA > 0:
+        noisy_bgr = add_awgn(img_bgr, NOISE_SIGMA)
+    else:
+        noisy_bgr = img_bgr
+
+    # ---- 预处理（对加噪图） ----
+    tensor, (orig_h, orig_w) = preprocess(noisy_bgr, model_h, model_w)
+
+    # ---- AX 推理 ----
+    result = session.run(None, {input_name: tensor})[0]
+
+    # ---- 后处理 & 还原原始尺寸 ----
+    result_bgr = postprocess(result, orig_h, orig_w)
+
+    # ---- 三图拼接输出 ----
+    label_mid = f"Noisy (sigma={NOISE_SIGMA})" if NOISE_SIGMA > 0 else "Input"
+    concat = make_concat(img_bgr, noisy_bgr, result_bgr, label_mid=label_mid)
+
+    name = os.path.splitext(os.path.basename(img_path))[0]
+    out_path = os.path.join(OUTPUT_DIR, "axmodel_res.png")
+    cv2.imwrite(out_path, concat)
+    print(f"输出已保存: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

DnCNN/python/onnx_infer.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+"""
+DnCNN ONNX 单图推理脚本
+- 读取原图 → 加 AWGN 噪声 → 预处理 → ONNX 推理 → 后处理 → 还原原图大小
+- 输出: 原图 + 加噪图 + 结果图 的三图左右拼接（带标注）
+- 无 torch 依赖，仅需 cv2 / numpy / onnxruntime
+- 所有参数已写为 default 常量，可直接运行
+"""
+
+import os
+import sys
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+# ============================================================
+# 默认参数（可按需修改）
+# ============================================================
+ONNX_PATH = os.path.join(os.path.dirname(__file__), "..", "..", "model_zoo", "dncnn_color_blind_640x640_sim.onnx")
+OUTPUT_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "results", "dncnn_onnx_infer")
+NOISE_SIGMA = 25               # 对原图施加的 AWGN 噪声强度（uint8 尺度，设为 0 则不加噪）
+PROVIDERS = ["CPUExecutionProvider"]  # ONNX Runtime 执行后端
+
+# ============================================================
+
+
+def load_image(img_path):
+    """读取图像，返回 BGR uint8 原始图"""
+    img_bgr = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+    if img_bgr is None:
+        raise FileNotFoundError(f"无法读取图像: {img_path}")
+    if img_bgr.ndim == 2:
+        img_bgr = cv2.cvtColor(img_bgr, cv2.COLOR_GRAY2BGR)
+    return img_bgr
+
+
+def add_awgn(img_bgr, sigma):
+    """对 BGR uint8 图像施加 AWGN，返回加噪后的 BGR uint8 图像"""
+    noise = np.random.randn(*img_bgr.shape).astype(np.float32) * sigma
+    noisy = img_bgr.astype(np.float32) + noise
+    noisy = np.clip(noisy, 0, 255).astype(np.uint8)
+    return noisy
+
+
+def preprocess(img_bgr, model_h, model_w):
+    """
+    预处理: BGR->RGB, resize to model size, normalize [0,1], HWC->CHW, add batch
+    返回: (1, 3, H, W) float32 张量, 原始尺寸 (h, w)
+    """
+    orig_h, orig_w = img_bgr.shape[:2]
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    img_resized = cv2.resize(img_rgb, (model_w, model_h), interpolation=cv2.INTER_LINEAR)
+    img_float = img_resized.astype(np.float32) / 255.0
+    tensor = np.transpose(img_float, (2, 0, 1))[np.newaxis, ...].astype(np.float32)
+    return tensor, (orig_h, orig_w)
+
+
+def postprocess(tensor, orig_h, orig_w):
+    """
+    后处理: squeeze batch, CHW->HWC, clip [0,1], uint8, resize 回原始尺寸
+    返回: BGR uint8 图像
+    """
+    arr = np.clip(np.squeeze(tensor, axis=0), 0.0, 1.0)          # (3, H, W)
+    arr = np.transpose(arr, (1, 2, 0))                            # (H, W, 3)
+    arr_uint = (arr * 255.0).round().astype(np.uint8)
+    arr_uint = cv2.resize(arr_uint, (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)
+    result_bgr = cv2.cvtColor(arr_uint, cv2.COLOR_RGB2BGR)
+    return result_bgr
+
+
+def make_concat(original_bgr, noisy_bgr, result_bgr,
+                label_left="Original", label_mid="Noisy", label_right="DnCNN ONNX"):
+    """左中右拼接原图、加噪图与结果图，并添加顶部标注"""
+    imgs = [original_bgr, noisy_bgr, result_bgr]
+    labels = [label_left, label_mid, label_right]
+    hs = [im.shape[0] for im in imgs]
+    h = max(hs)
+
+    resized = []
+    for im in imgs:
+        hh, ww = im.shape[:2]
+        if hh != h:
+            im = cv2.resize(im, (int(ww * h / hh), h), interpolation=cv2.INTER_LINEAR)
+        resized.append(im)
+
+    ws = [im.shape[1] for im in resized]
+    total_w = sum(ws)
+    label_h = max(30, h // 25)
+    canvas = np.full((h + label_h, total_w, 3), 255, dtype=np.uint8)
+
+    x = 0
+    for idx, im in enumerate(resized):
+        canvas[label_h:, x:x + ws[idx]] = im
+        x += ws[idx]
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = label_h / 30.0
+    thickness = max(1, int(font_scale))
+    color = (0, 0, 0)
+
+    x = 0
+    for idx, (label, w) in enumerate(zip(labels, ws)):
+        (tw, th), _ = cv2.getTextSize(label, font, font_scale, thickness)
+        cv2.putText(canvas, label, (x + w // 2 - tw // 2, label_h - (label_h - th) // 2),
+                    font, font_scale, color, thickness, cv2.LINE_AA)
+        x += w
+
+    return canvas
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"用法: python {os.path.basename(__file__)} <图像路径>")
+        print(f"默认 ONNX 模型: {ONNX_PATH}")
+        print(f"噪声 sigma: {NOISE_SIGMA}")
+        print(f"输出目录: {OUTPUT_DIR}")
+        sys.exit(1)
+
+    img_path = sys.argv[1]
+    if not os.path.isfile(img_path):
+        print(f"错误: 图像不存在: {img_path}")
+        sys.exit(1)
+    if not os.path.isfile(ONNX_PATH):
+        print(f"错误: ONNX 模型不存在: {ONNX_PATH}")
+        print(f"请修改脚本顶部 ONNX_PATH 常量，或先导出 ONNX 模型。")
+        sys.exit(1)
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # ---- 加载 ONNX 模型 ----
+    session = ort.InferenceSession(ONNX_PATH, providers=PROVIDERS)
+    input_name = session.get_inputs()[0].name
+    _, _, model_h, model_w = session.get_inputs()[0].shape
+
+    # ---- 读取原图 ----
+    img_bgr = load_image(img_path)
+
+    # ---- 加噪 ----
+    if NOISE_SIGMA > 0:
+        noisy_bgr = add_awgn(img_bgr, NOISE_SIGMA)
+    else:
+        noisy_bgr = img_bgr
+
+    # ---- 预处理（对加噪图） ----
+    tensor, (orig_h, orig_w) = preprocess(noisy_bgr, model_h, model_w)
+
+    # ---- ONNX 推理 ----
+    result = session.run(None, {input_name: tensor})[0]
+
+    # ---- 后处理 & 还原原始尺寸 ----
+    result_bgr = postprocess(result, orig_h, orig_w)
+
+    # ---- 三图拼接输出 ----
+    label_mid = f"Noisy (sigma={NOISE_SIGMA})" if NOISE_SIGMA > 0 else "Input"
+    concat = make_concat(img_bgr, noisy_bgr, result_bgr, label_mid=label_mid)
+
+    name = os.path.splitext(os.path.basename(img_path))[0]
+    out_path = os.path.join(OUTPUT_DIR, f"{name}_concat.png")
+    cv2.imwrite(out_path, concat)
+    print(f"输出已保存: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

FFDNet/model_convert/FFDNet.json

@@ -0,0 +1,58 @@
+{
+  "input": "./ffdnet_color_fixed_sigma10_416x416_sim.onnx",
+  "output_dir": "./FFDNet",
+  "output_name": "ffdnet_color_fixed_sigma10_416x416_sim.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./BSD.tar.gz",
+        "calibration_size": 32,
+        "calibration_mean": [0.0, 0.0, 0.0],
+        "calibration_std": [255.0, 255.0, 255.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    // "enable_smooth_quant": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cuda:1",
+    // "layer_configs": [
+    //   {
+    //     "start_tensor_names": ["DEFAULT"],
+    //     "end_tensor_names": ["DEFAULT"],
+    //     "data_type": "U16"
+    //   }
+    // ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+    // {
+    //   "tensor_name": "input",
+    //   "tensor_format": "RGB",
+    //   "tensor_layout": "NCHW",
+    //   "src_format": "YUV420SP",
+    //   "src_layout": "NHWC",
+    //   "src_dtype": "U8",
+    //   "csc_mode": "FullRange",
+    //   "csc_mat": [1.164, 0, 1.596, -222.912, 1.164, -0.392, -0.813, 135.616, 1.164, 2.017, 0, -276.8]
+    // }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

FFDNet/model_convert/axmodel/ffdnet_color_fixed_sigma10_640x640_sim.axmodel

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

FFDNet/python/axmodel_infer.py

@@ -0,0 +1,161 @@
+#!/usr/bin/env python3
+import os
+import sys
+import cv2
+import numpy as np
+import axengine as axe
+
+# ============================================================
+# 默认参数（可按需修改）
+# ============================================================
+AXMODEL_PATH = './ffdnet_color_fixed_sigma10_640x640_sim.axmodel'
+OUTPUT_DIR = './'
+# AX 量化模型输入格式: "float32" 或 "uint8"，取决于编译时的量化配置
+INPUT_DTYPE = "uint8"           # 量化模型通常为 uint8；float 模型设为 "float32"
+USE_FIXED_SIGMA = True         # True: 单输入模型；False: 双输入模型（input + sigma）
+MODEL_SIGMA = 10               # 模型 sigma（uint8 尺度，仅 USE_FIXED_SIGMA=False 时生效）
+NOISE_SIGMA = 10               # 对原图施加的 AWGN 噪声强度（uint8 尺度，设为 0 则不加噪）
+
+# ============================================================
+
+
+def load_image(img_path):
+    """读取图像，返回 BGR uint8 原始图"""
+    img_bgr = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+    if img_bgr is None:
+        raise FileNotFoundError(f"无法读取图像: {img_path}")
+    if img_bgr.ndim == 2:
+        img_bgr = cv2.cvtColor(img_bgr, cv2.COLOR_GRAY2BGR)
+    return img_bgr
+
+
+def add_awgn(img_bgr, sigma):
+    """对 BGR uint8 图像施加 AWGN，返回加噪后的 BGR uint8 图像"""
+    noise = np.random.randn(*img_bgr.shape).astype(np.float32) * sigma
+    noisy = img_bgr.astype(np.float32) + noise
+    noisy = np.clip(noisy, 0, 255).astype(np.uint8)
+    return noisy
+
+
+def preprocess(img_bgr, model_h, model_w):
+    """
+    预处理: BGR->RGB, resize to model size, 按 INPUT_DTYPE 做归一化或保持 uint8
+    返回: 模型输入张量, 原始尺寸 (h, w)
+    """
+    orig_h, orig_w = img_bgr.shape[:2]
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    img_resized = cv2.resize(img_rgb, (model_w, model_h), interpolation=cv2.INTER_LINEAR)
+
+    if INPUT_DTYPE == "float32":
+        img_float = img_resized.astype(np.float32) / 255.0
+        tensor = np.transpose(img_float, (2, 0, 1))[np.newaxis, ...].astype(np.float32)
+    else:
+        tensor = np.transpose(img_resized, (2, 0, 1))[np.newaxis, ...].astype(np.uint8)
+    return tensor, (orig_h, orig_w)
+
+
+def postprocess(tensor, orig_h, orig_w):
+    """
+    后处理: squeeze batch, CHW->HWC, clip, uint8, resize 回原始尺寸
+    返回: BGR uint8 图像
+    """
+    if tensor.dtype == np.uint8:
+        arr = np.squeeze(tensor, axis=0)
+        arr = np.transpose(arr, (1, 2, 0))
+        arr_uint = arr
+    else:
+        arr = np.clip(np.squeeze(tensor, axis=0), 0.0, 1.0)
+        arr = np.transpose(arr, (1, 2, 0))
+        arr_uint = (arr * 255.0).round().astype(np.uint8)
+    arr_uint = cv2.resize(arr_uint, (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)
+    result_bgr = cv2.cvtColor(arr_uint, cv2.COLOR_RGB2BGR)
+    return result_bgr
+
+
+def make_concat(original_bgr, noisy_bgr, result_bgr,
+                label_left="Original", label_mid="Noisy", label_right="FFDNet AXModel"):
+    """左中右拼接原图、加噪图与结果图，并添加顶部标注"""
+    imgs = [original_bgr, noisy_bgr, result_bgr]
+    labels = [label_left, label_mid, label_right]
+    hs = [im.shape[0] for im in imgs]
+    h = max(hs)
+
+    resized = []
+    for im in imgs:
+        hh, ww = im.shape[:2]
+        if hh != h:
+            im = cv2.resize(im, (int(ww * h / hh), h), interpolation=cv2.INTER_LINEAR)
+        resized.append(im)
+
+    ws = [im.shape[1] for im in resized]
+    total_w = sum(ws)
+    label_h = max(30, h // 25)
+    canvas = np.full((h + label_h, total_w, 3), 255, dtype=np.uint8)
+
+    x = 0
+    for idx, im in enumerate(resized):
+        canvas[label_h:, x:x + ws[idx]] = im
+        x += ws[idx]
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = label_h / 30.0
+    thickness = max(1, int(font_scale))
+    color = (0, 0, 0)
+
+    x = 0
+    for idx, (label, w) in enumerate(zip(labels, ws)):
+        (tw, th), _ = cv2.getTextSize(label, font, font_scale, thickness)
+        cv2.putText(canvas, label, (x + w // 2 - tw // 2, label_h - (label_h - th) // 2),
+                    font, font_scale, color, thickness, cv2.LINE_AA)
+        x += w
+
+    return canvas
+
+
+def main():
+    img_path = './3096.png'  # 输入图像路径，可按需修改
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # ---- 加载 AX 模型 ----
+    session = axe.InferenceSession(AXMODEL_PATH, providers=["AxEngineExecutionProvider"])
+    input_name = session.get_inputs()[0].name
+    _, _, model_h, model_w = session.get_inputs()[0].shape
+
+    # ---- 读取原图 ----
+    img_bgr = load_image(img_path)
+
+    # ---- 加噪 ----
+    if NOISE_SIGMA > 0:
+        noisy_bgr = add_awgn(img_bgr, NOISE_SIGMA)
+    else:
+        noisy_bgr = img_bgr
+
+    # ---- 预处理（对加噪图） ----
+    tensor, (orig_h, orig_w) = preprocess(noisy_bgr, model_h, model_w)
+
+    # ---- AX 推理 ----
+    if USE_FIXED_SIGMA:
+        result = session.run(None, {input_name: tensor})[0]
+    else:
+        sigma_dtype = np.float32 if INPUT_DTYPE == "float32" else np.uint8
+        sigma_tensor = np.full((1, 1, 1, 1), MODEL_SIGMA / 255.0 if INPUT_DTYPE == "float32" else MODEL_SIGMA, dtype=sigma_dtype)
+        sigma_name = session.get_inputs()[1].name
+        result = session.run(None, {input_name: tensor, sigma_name: sigma_tensor})[0]
+
+    # ---- 后处理 & 还原原始尺寸 ----
+    result_bgr = postprocess(result, orig_h, orig_w)
+
+    # ---- 三图拼接输出 ----
+    label_right = f"FFDNet AXModel (sigma={MODEL_SIGMA})" if not USE_FIXED_SIGMA else "FFDNet AXModel"
+    label_mid = f"Noisy (sigma={NOISE_SIGMA})" if NOISE_SIGMA > 0 else "Input"
+    concat = make_concat(img_bgr, noisy_bgr, result_bgr,
+                         label_mid=label_mid, label_right=label_right)
+
+    name = os.path.splitext(os.path.basename(img_path))[0]
+    out_path = os.path.join(OUTPUT_DIR, "axmodel_res.png")
+    cv2.imwrite(out_path, concat)
+    print(f"输出已保存: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

FFDNet/python/onnx_infer.py

@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+FFDNet ONNX 单图推理脚本
+- 读取原图 → 加 AWGN 噪声 → 预处理 → ONNX 推理 → 后处理 → 还原原图大小
+- 输出: 原图 + 加噪图 + 结果图 的三图左右拼接（带标注）
+- 无 torch 依赖，仅需 cv2 / numpy / onnxruntime
+- 所有参数已写为 default 常量，可直接运行
+"""
+
+import os
+import sys
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+# ============================================================
+# 默认参数（可按需修改）
+# ============================================================
+ONNX_PATH = os.path.join(os.path.dirname(__file__), "..", "..", "model_zoo", "ffdnet_color_fixed_sigma10_640x640_sim.onnx")
+OUTPUT_DIR = os.path.join(os.path.dirname(__file__), "..", "..", "results", "ffdnet_onnx_infer")
+# 若使用非固定 sigma 的模型，设置 USE_FIXED_SIGMA = False 并填写 MODEL_SIGMA
+USE_FIXED_SIGMA = True         # True: 单输入 fixed-sigma 模型
+MODEL_SIGMA = 10               # 模型 sigma（uint8 尺度，仅 USE_FIXED_SIGMA=False 时生效）
+NOISE_SIGMA = 10               # 对原图施加的 AWGN 噪声强度（uint8 尺度，设为 0 则不加噪）
+PROVIDERS = ["CPUExecutionProvider"]  # ONNX Runtime 执行后端
+
+# ============================================================
+
+
+def load_image(img_path):
+    """读取图像，返回 BGR uint8 原始图"""
+    img_bgr = cv2.imread(img_path, cv2.IMREAD_UNCHANGED)
+    if img_bgr is None:
+        raise FileNotFoundError(f"无法读取图像: {img_path}")
+    if img_bgr.ndim == 2:
+        img_bgr = cv2.cvtColor(img_bgr, cv2.COLOR_GRAY2BGR)
+    return img_bgr
+
+
+def add_awgn(img_bgr, sigma):
+    """对 BGR uint8 图像施加 AWGN，返回加噪后的 BGR uint8 图像"""
+    noise = np.random.randn(*img_bgr.shape).astype(np.float32) * sigma
+    noisy = img_bgr.astype(np.float32) + noise
+    noisy = np.clip(noisy, 0, 255).astype(np.uint8)
+    return noisy
+
+
+def preprocess(img_bgr, model_h, model_w):
+    """
+    预处理: BGR->RGB, resize to model size, normalize [0,1], HWC->CHW, add batch
+    返回: (1, 3, H, W) float32 张量, 原始尺寸 (h, w)
+    """
+    orig_h, orig_w = img_bgr.shape[:2]
+    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+    img_resized = cv2.resize(img_rgb, (model_w, model_h), interpolation=cv2.INTER_LINEAR)
+    img_float = img_resized.astype(np.float32) / 255.0
+    tensor = np.transpose(img_float, (2, 0, 1))[np.newaxis, ...].astype(np.float32)
+    return tensor, (orig_h, orig_w)
+
+
+def postprocess(tensor, orig_h, orig_w):
+    """
+    后处理: squeeze batch, CHW->HWC, clip [0,1], uint8, resize 回原始尺寸
+    返回: BGR uint8 图像
+    """
+    arr = np.clip(np.squeeze(tensor, axis=0), 0.0, 1.0)          # (3, H, W)
+    arr = np.transpose(arr, (1, 2, 0))                            # (H, W, 3)
+    arr_uint = (arr * 255.0).round().astype(np.uint8)
+    arr_uint = cv2.resize(arr_uint, (orig_w, orig_h), interpolation=cv2.INTER_LINEAR)
+    result_bgr = cv2.cvtColor(arr_uint, cv2.COLOR_RGB2BGR)
+    return result_bgr
+
+
+def make_concat(original_bgr, noisy_bgr, result_bgr,
+                label_left="Original", label_mid="Noisy", label_right="FFDNet ONNX"):
+    """左中右拼接原图、加噪图与结果图，并添加顶部标注"""
+    imgs = [original_bgr, noisy_bgr, result_bgr]
+    labels = [label_left, label_mid, label_right]
+    hs = [im.shape[0] for im in imgs]
+    h = max(hs)
+
+    # 统一高度
+    resized = []
+    for im in imgs:
+        hh, ww = im.shape[:2]
+        if hh != h:
+            im = cv2.resize(im, (int(ww * h / hh), h), interpolation=cv2.INTER_LINEAR)
+        resized.append(im)
+
+    ws = [im.shape[1] for im in resized]
+    total_w = sum(ws)
+    label_h = max(30, h // 25)
+    canvas = np.full((h + label_h, total_w, 3), 255, dtype=np.uint8)
+
+    x = 0
+    for idx, im in enumerate(resized):
+        canvas[label_h:, x:x + ws[idx]] = im
+        x += ws[idx]
+
+    # 标注文字
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = label_h / 30.0
+    thickness = max(1, int(font_scale))
+    color = (0, 0, 0)
+
+    x = 0
+    for idx, (label, w) in enumerate(zip(labels, ws)):
+        (tw, th), _ = cv2.getTextSize(label, font, font_scale, thickness)
+        cv2.putText(canvas, label, (x + w // 2 - tw // 2, label_h - (label_h - th) // 2),
+                    font, font_scale, color, thickness, cv2.LINE_AA)
+        x += w
+
+    return canvas
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(f"用法: python {os.path.basename(__file__)} <图像路径>")
+        print(f"默认 ONNX 模型: {ONNX_PATH}")
+        print(f"噪声 sigma: {NOISE_SIGMA}")
+        print(f"输出目录: {OUTPUT_DIR}")
+        sys.exit(1)
+
+    img_path = sys.argv[1]
+    if not os.path.isfile(img_path):
+        print(f"错误: 图像不存在: {img_path}")
+        sys.exit(1)
+    if not os.path.isfile(ONNX_PATH):
+        print(f"错误: ONNX 模型不存在: {ONNX_PATH}")
+        print(f"请修改脚本顶��� ONNX_PATH 常量，或先导出 ONNX 模型。")
+        sys.exit(1)
+
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+
+    # ---- 加载 ONNX 模型 ----
+    session = ort.InferenceSession(ONNX_PATH, providers=PROVIDERS)
+    input_name = session.get_inputs()[0].name
+    _, _, model_h, model_w = session.get_inputs()[0].shape
+
+    # ---- 读取原图 ----
+    img_bgr = load_image(img_path)
+
+    # ---- 加噪 ----
+    if NOISE_SIGMA > 0:
+        noisy_bgr = add_awgn(img_bgr, NOISE_SIGMA)
+    else:
+        noisy_bgr = img_bgr
+
+    # ---- 预处理（对加噪图） ----
+    tensor, (orig_h, orig_w) = preprocess(noisy_bgr, model_h, model_w)
+
+    # ---- ONNX 推理 ----
+    if USE_FIXED_SIGMA:
+        result = session.run(None, {input_name: tensor})[0]
+    else:
+        sigma_tensor = np.full((1, 1, 1, 1), MODEL_SIGMA / 255.0, dtype=np.float32)
+        sigma_name = session.get_inputs()[1].name
+        result = session.run(None, {input_name: tensor, sigma_name: sigma_tensor})[0]
+
+    # ---- 后处理 & 还原原始尺寸 ----
+    result_bgr = postprocess(result, orig_h, orig_w)
+
+    # ---- 三图拼接输出 ----
+    label_right = f"FFDNet ONNX (sigma={MODEL_SIGMA})" if not USE_FIXED_SIGMA else "FFDNet ONNX"
+    label_mid = f"Noisy (sigma={NOISE_SIGMA})" if NOISE_SIGMA > 0 else "Input"
+    concat = make_concat(img_bgr, noisy_bgr, result_bgr,
+                         label_mid=label_mid, label_right=label_right)
+
+    name = os.path.splitext(os.path.basename(img_path))[0]
+    out_path = os.path.join(OUTPUT_DIR, f"{name}_concat.png")
+    cv2.imwrite(out_path, concat)
+    print(f"输出已保存: {out_path}")
+
+
+if __name__ == "__main__":
+    main()

NAFNet/model_convert/NAFNet.json

@@ -0,0 +1,58 @@
+{
+  "input": "./NAFNet-SIDD-width64-256x256.onnx",
+  "output_dir": "./NAFNet",
+  "output_name": "NAFNet_1_3_256_256.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "input",
+        "calibration_dataset": "./SIDD.tar.gz",
+        "calibration_size": 32,
+        "calibration_mean": [0.0, 0.0, 0.0],
+        "calibration_std": [255.0, 255.0, 255.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level":1,
+    // "enable_smooth_quant": true,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend", 
+    "device": "cuda:1",
+    // "layer_configs": [
+    //   {
+    //     "start_tensor_names": ["DEFAULT"],
+    //     "end_tensor_names": ["DEFAULT"],
+    //     "data_type": "U16"
+    //   }
+    // ]
+  },
+  "input_processors": [
+    {
+      "tensor_name": "input",
+      "tensor_format": "RGB",
+      "tensor_layout": "NCHW",
+      "src_format": "BGR",
+      "src_dtype": "U8",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC"
+    }
+    // {
+    //   "tensor_name": "input",
+    //   "tensor_format": "RGB",
+    //   "tensor_layout": "NCHW",
+    //   "src_format": "YUV420SP",
+    //   "src_layout": "NHWC",
+    //   "src_dtype": "U8",
+    //   "csc_mode": "FullRange",
+    //   "csc_mat": [1.164, 0, 1.596, -222.912, 1.164, -0.392, -0.813, 135.616, 1.164, 2.017, 0, -276.8]
+    // }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}
+

NAFNet/model_convert/axmodel/NAFNet_1_3_256_256.axmodel

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

NAFNet/python/axmodel_infer.py

@@ -0,0 +1,69 @@
+#!/usr/bin/env python3
+"""Single-image NAFNet axmodel inference with side-by-side comparison output."""
+
+import os
+
+import cv2
+import numpy as np
+import axengine as axe
+
+# ============================================================
+# 默认参数（按需修改）
+# ============================================================
+AXMODEL_PATH = 'NAFNet_1_3_256_256.axmodel'
+INPUT_PATH = 'demo/noisy.png'
+OUTPUT_PATH = 'axmodel_compare.png'
+
+
+def read_image(path):
+    bgr = cv2.imread(path, cv2.IMREAD_COLOR)
+    if bgr is None:
+        raise FileNotFoundError(f'Cannot read image: {path}')
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB).astype(np.uint8)
+    tensor = np.transpose(rgb, (2, 0, 1))[None, ...]
+    return tensor, bgr
+
+
+def save_comparison(orig_bgr, output_tensor, path):
+    """拼接原图与结果图并标注文字，输出图还原到原图大小后再拼接"""
+    output = np.squeeze(output_tensor, axis=0)
+    output = np.clip(output, 0.0, 1.0)
+    output_rgb = np.transpose(output, (1, 2, 0))
+    output_bgr = cv2.cvtColor((output_rgb * 255.0).round().astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+    h, w = orig_bgr.shape[:2]
+    if output_bgr.shape[:2] != (h, w):
+        output_bgr = cv2.resize(output_bgr, (w, h), interpolation=cv2.INTER_LINEAR)
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = max(h, w) / 512.0
+    thickness = max(1, int(font_scale * 2))
+    color = (255, 255, 255)
+
+    cv2.putText(orig_bgr, 'noisy', (int(10 * font_scale), int(30 * font_scale)),
+                font, font_scale, color, thickness, cv2.LINE_AA)
+    cv2.putText(output_bgr, 'denoised', (int(10 * font_scale), int(30 * font_scale)),
+                font, font_scale, color, thickness, cv2.LINE_AA)
+
+    compare = np.concatenate([orig_bgr, output_bgr], axis=1)
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+    cv2.imwrite(path, compare)
+
+
+def main():
+    inp, orig_bgr = read_image(INPUT_PATH)
+
+    session = axe.InferenceSession(AXMODEL_PATH, providers=['AxEngineExecutionProvider'])
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+    expected_shape = session.get_inputs()[0].shape
+    if list(inp.shape) != expected_shape:
+        raise ValueError(f'Input shape {list(inp.shape)} does not match fixed axmodel shape {expected_shape}.')
+
+    out = session.run([output_name], {input_name: inp})[0]
+    save_comparison(orig_bgr, out, OUTPUT_PATH)
+    print(f'axmodel inference finished: {OUTPUT_PATH}')
+
+
+if __name__ == '__main__':
+    main()

NAFNet/python/onnx_infer.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+"""Single-image NAFNet ONNX inference with side-by-side comparison output."""
+
+import os
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+# ============================================================
+# 默认参数（按需修改）
+# ============================================================
+ONNX_PATH = 'experiments/onnx/NAFNet-SIDD-width64-256x256.onnx'
+INPUT_PATH = 'demo/noisy.png'
+OUTPUT_PATH = 'demo/denoise_onnx_compare.png'
+
+
+def read_image(path):
+    bgr = cv2.imread(path, cv2.IMREAD_COLOR)
+    if bgr is None:
+        raise FileNotFoundError(f'Cannot read image: {path}')
+    rgb = cv2.cvtColor(bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    tensor = np.transpose(rgb, (2, 0, 1))[None, ...]
+    return tensor, bgr
+
+
+def save_comparison(orig_bgr, output_tensor, path):
+    """拼接原图与结果图并标注文字，输出图还原到原图大小后再拼接"""
+    output = np.squeeze(output_tensor, axis=0)
+    output = np.clip(output, 0.0, 1.0)
+    output_rgb = np.transpose(output, (1, 2, 0))
+    output_bgr = cv2.cvtColor((output_rgb * 255.0).round().astype(np.uint8), cv2.COLOR_RGB2BGR)
+
+    h, w = orig_bgr.shape[:2]
+    if output_bgr.shape[:2] != (h, w):
+        output_bgr = cv2.resize(output_bgr, (w, h), interpolation=cv2.INTER_LINEAR)
+
+    font = cv2.FONT_HERSHEY_SIMPLEX
+    font_scale = max(h, w) / 512.0
+    thickness = max(1, int(font_scale * 2))
+    color = (255, 255, 255)
+
+    cv2.putText(orig_bgr, 'input', (int(10 * font_scale), int(30 * font_scale)),
+                font, font_scale, color, thickness, cv2.LINE_AA)
+    cv2.putText(output_bgr, 'onnx', (int(10 * font_scale), int(30 * font_scale)),
+                font, font_scale, color, thickness, cv2.LINE_AA)
+
+    compare = np.concatenate([orig_bgr, output_bgr], axis=1)
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+    cv2.imwrite(path, compare)
+
+
+def main():
+    inp, orig_bgr = read_image(INPUT_PATH)
+
+    providers = ['CUDAExecutionProvider', 'CPUExecutionProvider'] if ort.get_device() == 'GPU' else ['CPUExecutionProvider']
+    session = ort.InferenceSession(ONNX_PATH, providers=providers)
+    input_name = session.get_inputs()[0].name
+    output_name = session.get_outputs()[0].name
+    expected_shape = session.get_inputs()[0].shape
+    if list(inp.shape) != expected_shape:
+        raise ValueError(f'Input shape {list(inp.shape)} does not match fixed ONNX shape {expected_shape}.')
+
+    out = session.run([output_name], {input_name: inp.astype(np.float32)})[0]
+    save_comparison(orig_bgr, out, OUTPUT_PATH)
+    print(f'ONNX inference finished: {OUTPUT_PATH}')
+
+
+if __name__ == '__main__':
+    main()

README.md

@@ -0,0 +1,107 @@
+---
+license: mit
+language:
+- en
+pipeline_tag: image-to-image
+tags:
+- denosing
+- ImageEnhancement
+---
+
+# ImageDenosing
+
+This is a collection of image denosing algorithms, models have been converted to run on the Axera NPU using **w8a8** quantization.
+
+This model has been optimized with the following LoRA: 
+
+Compatible with Pulsar2 version: 6.0 115775d3
+
+## Convert tools links:
+
+For those who are interested in model conversion, you can try to export axmodel through 
+
+- [Pulsar2 Link, How to Convert ONNX to axmodel](https://pulsar2-docs.readthedocs.io/en/latest/pulsar2/introduction.html) 
+
+
+## Support Platform
+
+- AX650
+  - [M4N-Dock(爱芯派Pro)](https://wiki.sipeed.com/hardware/zh/maixIV/m4ndock/m4ndock.html)
+  - [M.2 Accelerator card](https://docs.m5stack.com/en/ai_hardware/LLM-8850_Card)
+  
+
+## 性能基准测试 (Performance Benchmark)
+
+| 模型 | 输入分辨率 | AX650板端耗时 |
+|------|-----------|--------------|
+| NAFNet | 256×256 | 87ms |
+| DnCNN | 416×416 | 22ms |
+| FFDNet | 640×640 | 19.3ms |
+| FastDVDnet | 640×480 | 61.2ms |
+
+## How to use
+
+Download all files from this repository to the device
+
+```
+模型文件组织方式如下：
+.
+|-- demo
+|   `-- noisy.png
+|-- model_convert
+|   |-- NAFNet.json
+|   `-- axmodel
+|       `-- NAFNet_1_3_256_256.axmodel
+|-- python
+|   |-- axmodel_infer.py
+|   `-- onnx_infer.py
+`-- res
+    `-- axmodel_compare.png
+
+
+```
+
+### Inference
+#### Image Denoising
+
+图片推理，执行命令`python3 axmodel_infer.py`:
+```
+(base) root@ax650:~/NAFNet# python3 axmodel_infer.py
+[INFO] Available providers:  ['AxEngineExecutionProvider', 'AXCLRTExecutionProvider']
+[INFO] Using provider: AxEngineExecutionProvider
+[INFO] Chip type: ChipType.MC50
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Engine version: 2.12.0s
+[INFO] Model type: 2 (triple core)
+[INFO] Compiler version: 6.0 115775d3
+axmodel inference finished: axmodel_compare.png
+
+```
+
+推理结果样例：
+![alt text](NAFNet/res/axmodel_compare.png)
+
+#### Video Denoising
+
+视频推理，执行命令`python3 axmodel_video_infer.py`:
+```
+(base) root@ax650:~/fastdvdnet# python3 axmodel_video_infer.py
+[INFO] Available providers:  ['AxEngineExecutionProvider', 'AXCLRTExecutionProvider']
+[INFO] Using provider: AxEngineExecutionProvider
+[INFO] Chip type: ChipType.MC50
+[INFO] VNPU type: VNPUType.DISABLED
+[INFO] Engine version: 2.12.0s
+[INFO] Model type: 2 (triple core)
+[INFO] Compiler version: 6.0 115775d3
+providers: AxEngineExecutionProvider
+inputs: [('noisy', [1, 15, 480, 640], 'float32'), ('noise_map', [1, 1, 480, 640], 'float32')]
+outputs: [('denoised', [1, 3, 480, 640])]
+video: 854x480 @ 25.0fps, 67 frames
+axmodel input: 640x480
+[OK] ./people-sunset.mp4 -> ./people-sunset_axmodel_side_by_side.mp4
+     frames=67 time=17.57s fps=3.81
+
+```
+
+视频降噪样例：
+<video controls src="fastDVDnet/res/people-sunset_axmodel_side_by_side.mp4" title="Title"></video>

fastDVDnet/model_quant/fastDVDnet.json

@@ -0,0 +1,58 @@
+// 临时跑通版，真实需要拼接图做15通道输入
+{
+  "input": "./fastdvdnet_640x480.onnx",
+  "output_dir": "./fastdvdnet",
+  "output_name": "fastdvdnet_640x480.axmodel",
+  "model_type": "ONNX",
+  "target_hardware": "AX650",
+  "npu_mode": "NPU3",
+  "quant": {
+    "input_configs": [
+      {
+        "tensor_name": "noisy",
+        "calibration_dataset": "fastdvdnet.tar.gz",
+        "calibration_format": "Numpy",
+        "calibration_size": 5,
+        "calibration_mean": [0.0],
+        "calibration_std": [1.0]
+      },
+      {
+        "tensor_name": "noise_map",
+        "calibration_dataset": "./fastDVD_noise_map.tar.gz",
+        "calibration_format": "Numpy",
+        "calibration_size": 5,
+        "calibration_mean": [0.0],
+        "calibration_std": [1.0]
+      }
+    ],
+    "calibration_method": "MinMax",
+    "precision_analysis": true,
+    "transformer_opt_level": 1,
+    "precision_analysis_method": "EndToEnd",
+    "precision_analysis_mode": "NPUBackend",
+    "device": "cuda:1"
+  },
+  "input_processors": [
+    {
+      "tensor_name": "noisy",
+      "tensor_layout": "NCHW",
+      "src_dtype": "FP32",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC",
+      "mean": [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0],
+      "std": [1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0]
+    },
+    {
+      "tensor_name": "noise_map",
+      "tensor_layout": "NCHW",
+      "src_dtype": "FP32",
+      "src_layout": "NCHW",
+      "csc_mode": "NoCSC",
+      "mean": [0.0],
+      "std": [1.0]
+    }
+  ],
+  "compiler": {
+    "check": 2
+  }
+}

fastDVDnet/python/axmodel_video_infer.py

@@ -0,0 +1,166 @@
+#!/usr/bin/env python
+"""FastDVDnet axmodel video inference, side-by-side output.
+Input: mp4 video -> resize to axmodel fixed input -> 5-frame window -> axmodel -> output video.
+Input dtype is inferred from the axmodel session so both float and uint8 models work."""
+import argparse, os, time
+import cv2, numpy as np
+import axengine as axe
+
+
+def _resolve_numpy_dtype(dtype, fallback):
+    try:
+        return np.dtype(dtype)
+    except TypeError:
+        name = str(dtype).lower()
+        if "float16" in name or "fp16" in name:
+            return np.dtype(np.float16)
+        if "float" in name:
+            return np.dtype(np.float32)
+        if "uint8" in name:
+            return np.dtype(np.uint8)
+        if "int8" in name:
+            return np.dtype(np.int8)
+        return np.dtype(fallback)
+
+def read_video(video_path, max_frames=0):
+    cap=cv2.VideoCapture(video_path)
+    if not cap.isOpened(): raise RuntimeError('open fail: '+video_path)
+    fps=cap.get(cv2.CAP_PROP_FPS) or 25.0
+    ow=int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)); oh=int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    frames=[]
+    while True:
+        ok,f=cap.read()
+        if not ok: break
+        frames.append(f)
+        if max_frames and len(frames)>=max_frames: break
+    cap.release()
+    if not frames: raise RuntimeError('no frames')
+    return frames,fps,ow,oh
+
+def reflect_index(idx,length):
+    if length<=1: return 0
+    while idx<0 or idx>=length:
+        if idx<0: idx=-idx
+        if idx>=length: idx=2*(length-1)-idx
+    return idx
+
+def bgr_to_ax_input(fb, ah, aw, noisy_dtype):
+    r = cv2.resize(fb, (aw, ah), interpolation=cv2.INTER_AREA)
+    r = cv2.cvtColor(r, cv2.COLOR_BGR2RGB)
+    chw = r.transpose(2, 0, 1)
+    noisy_dtype = _resolve_numpy_dtype(noisy_dtype, np.float32)
+    if np.issubdtype(noisy_dtype, np.floating):
+        return (chw.astype(np.float32) / 255.0).astype(noisy_dtype, copy=False)
+    return chw.astype(noisy_dtype, copy=False)
+
+def chw_float_to_bgr_u8(chw,tw,th):
+    hwc=(chw*255.).clip(0,255).astype(np.uint8).transpose(1,2,0)
+    bgr=cv2.cvtColor(hwc,cv2.COLOR_RGB2BGR)
+    if bgr.shape[1]!=tw or bgr.shape[0]!=th:
+        bgr=cv2.resize(bgr,(tw,th),interpolation=cv2.INTER_LINEAR)
+    return bgr
+
+def denoise_axmodel(frames_bgr, noise_sigma_01, sess, ax_h, ax_w,
+                    input_names, output_names, noisy_dtype, noise_map_dtype):
+    numframes = len(frames_bgr)
+    temp_psz, ctrl = 5, 2
+
+    chw_cache = {}
+    def get_chw(i):
+        i = i % numframes
+        if i not in chw_cache:
+            chw_cache[i] = bgr_to_ax_input(
+                frames_bgr[reflect_index(i, numframes)], ax_h, ax_w, noisy_dtype)
+        return chw_cache[i]
+
+    den_frames_bgr = []
+    inframes = []
+
+    for fridx in range(numframes):
+        if not inframes:
+            for off in range(temp_psz):
+                inframes.append(get_chw(fridx + off - ctrl))
+        else:
+            del inframes[0]
+            inframes.append(get_chw(fridx + ctrl))
+
+        noisy = np.concatenate(inframes, axis=0)[None, :, :, :]
+        noise_map = np.full(
+            (1, 1, ax_h, ax_w),
+            noise_sigma_01,
+            dtype=_resolve_numpy_dtype(noise_map_dtype, np.float32),
+        )
+        feeds = {input_names[0]: noisy, input_names[1]: noise_map}
+        out = sess.run(output_names, feeds)[0]
+        out = np.clip(out, 0.0, 1.0)
+        den_bgr = chw_float_to_bgr_u8(
+            out[0], frames_bgr[0].shape[1], frames_bgr[0].shape[0])
+        den_frames_bgr.append(den_bgr)
+
+    return den_frames_bgr
+
+
+def write_side_by_side(frames_orig, frames_den, out_path, fps, label=True):
+    h, w = frames_orig[0].shape[:2]
+    os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(out_path, fourcc, fps, (w * 2, h))
+    if not writer.isOpened():
+        raise RuntimeError("video writer fail: {}".format(out_path))
+    for orig, den in zip(frames_orig, frames_den):
+        canvas = np.concatenate([orig, den], axis=1)
+        if label:
+            cv2.putText(canvas, "Original", (16, 34), cv2.FONT_HERSHEY_SIMPLEX,
+                        1.0, (0, 255, 255), 2, cv2.LINE_AA)
+            cv2.putText(canvas, "AXModel Denoised", (w + 16, 34), cv2.FONT_HERSHEY_SIMPLEX,
+                        1.0, (0, 255, 255), 2, cv2.LINE_AA)
+        writer.write(canvas)
+    writer.release()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="FastDVDnet axmodel video inference")
+    parser.add_argument("--axmodel", type=str, default="./fastdvdnet_640x480.axmodel")
+    parser.add_argument("--video", type=str, default='./people-sunset.mp4', help="input mp4 video")
+    parser.add_argument("--noise_sigma", type=float, default=25.0, help="0-255")
+    parser.add_argument("--out_dir", type=str, default="./")
+    parser.add_argument("--max_frames", type=int, default=0, help="0=all")
+    parser.add_argument("--no_label", action="store_true")
+    args = parser.parse_args()
+
+    sess = axe.InferenceSession(args.axmodel, providers=["AxEngineExecutionProvider"])
+    inputs = sess.get_inputs()
+    input_names = [i.name for i in inputs]
+    output_names = [o.name for o in sess.get_outputs()]
+    noisy_dtype = getattr(inputs[0], "dtype", np.float32)
+    noise_map_dtype = getattr(inputs[1], "dtype", np.float32)
+    ax_h = inputs[0].shape[2]
+    ax_w = inputs[0].shape[3]
+
+    print("providers:", sess.get_providers())
+    print("inputs:", [(n, list(i.shape), str(getattr(i, "dtype", "unknown"))) for n, i in zip(input_names, inputs)])
+    print("outputs:", [(n, list(o.shape)) for n, o in zip(output_names, sess.get_outputs())])
+
+    base = os.path.splitext(os.path.basename(args.video))[0]
+    out_path = os.path.join(args.out_dir, base + "_axmodel_side_by_side.mp4")
+
+    t0 = time.time()
+    frames_bgr, fps, orig_w, orig_h = read_video(args.video, args.max_frames)
+    print("video: {}x{} @ {:.1f}fps, {} frames".format(orig_w, orig_h, fps, len(frames_bgr)))
+    print("axmodel input: {}x{}".format(ax_w, ax_h))
+
+    sigma01 = args.noise_sigma / 255.0
+    den = denoise_axmodel(
+        frames_bgr, sigma01, sess, ax_h, ax_w,
+        input_names, output_names, noisy_dtype, noise_map_dtype,
+    )
+    write_side_by_side(frames_bgr, den, out_path, fps, label=not args.no_label)
+    dt = time.time() - t0
+
+    print("[OK] {} -> {}".format(args.video, out_path))
+    print("     frames={} time={:.2f}s fps={:.2f}".format(
+        len(frames_bgr), dt, len(frames_bgr) / max(dt, 0.001)))
+
+
+if __name__ == "__main__":
+    main()

fastDVDnet/python/onnx_video_infer.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python
+"""
+FastDVDnet ONNX 视频推理脚本，输出 原帧 | ONNX 去噪结果 拼接视频。
+
+输入视频逐帧 resize 到 ONNX 固定输入尺寸 (HxW)，组成 5 帧窗口
+[t-2,t-1,t,t+1,t+2] 推理，输出 resize 回原始尺寸生成拼接视频。
+
+用法:
+    python onnx_video_infer.py \
+        --onnx ./fastdvdnet_640x480.onnx \
+        --video mp4/drone.mp4 \
+        --noise_sigma 25 \
+        --out_dir ./video_infer_results/onnx_test
+"""
+import argparse
+import os
+import time
+
+import cv2
+import numpy as np
+import onnxruntime as ort
+
+
+def get_onnx_shapes(onnx_path):
+    import onnx
+    m = onnx.load(onnx_path)
+    x_dims = [d.dim_value for d in m.graph.input[0].type.tensor_type.shape.dim]
+    return x_dims  # [N, 15, H, W]
+
+
+def read_video(video_path, max_frames=0):
+    cap = cv2.VideoCapture(video_path)
+    if not cap.isOpened():
+        raise RuntimeError("failed to open video: {}".format(video_path))
+    fps = cap.get(cv2.CAP_PROP_FPS) or 25.0
+    orig_w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
+    orig_h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
+    frames_bgr = []
+    while True:
+        ok, frame = cap.read()
+        if not ok:
+            break
+        frames_bgr.append(frame)
+        if max_frames and len(frames_bgr) >= max_frames:
+            break
+    cap.release()
+    if not frames_bgr:
+        raise RuntimeError("no frames read from {}".format(video_path))
+    return frames_bgr, fps, orig_w, orig_h
+
+
+def reflect_index(idx, length):
+    if length <= 1:
+        return 0
+    while idx < 0 or idx >= length:
+        if idx < 0:
+            idx = -idx
+        if idx >= length:
+            idx = 2 * (length - 1) - idx
+    return idx
+
+
+def bgr_to_onnx_input(frame_bgr, onnx_h, onnx_w):
+    """resize BGR uint8 to ONNX RGB float32 [1,3,H,W] in [0,1]"""
+    resized = cv2.resize(frame_bgr, (onnx_w, onnx_h), interpolation=cv2.INTER_AREA)
+    rgb = cv2.cvtColor(resized, cv2.COLOR_BGR2RGB)
+    chw = rgb.astype(np.float32).transpose(2, 0, 1) / 255.0
+    return chw  # [3, H, W]
+
+
+def chw_to_bgr_uint8(chw, target_w, target_h):
+    """[3,H,W] float32 in [0,1] -> BGR uint8 resized to target_w x target_h"""
+    hwc = (chw * 255.0).clip(0, 255).astype(np.uint8).transpose(1, 2, 0)
+    rgb = hwc  # already RGB from ONNX output
+    bgr = cv2.cvtColor(rgb, cv2.COLOR_RGB2BGR)
+    if bgr.shape[1] != target_w or bgr.shape[0] != target_h:
+        bgr = cv2.resize(bgr, (target_w, target_h), interpolation=cv2.INTER_LINEAR)
+    return bgr
+
+
+def denoise_onnx(frames_bgr, noise_sigma_01, sess, x_shape, input_names, output_names):
+    numframes = len(frames_bgr)
+    _, _, onnx_h, onnx_w = x_shape
+    temp_psz, ctrl = 5, 2
+
+    # 缓存 resize 后的 CHW 帧
+    chw_cache = {}
+    def get_chw(i):
+        i = i % numframes
+        if i not in chw_cache:
+            chw_cache[i] = bgr_to_onnx_input(frames_bgr[reflect_index(i, numframes)], onnx_h, onnx_w)
+        return chw_cache[i]
+
+    den_frames_bgr = []
+    inframes = []  # numpy [3,H,W] each
+
+    for fridx in range(numframes):
+        if not inframes:
+            for off in range(temp_psz):
+                inframes.append(get_chw(fridx + off - ctrl))
+        else:
+            del inframes[0]
+            inframes.append(get_chw(fridx + ctrl))
+
+        # concat 5 frames -> [1, 15, H, W]
+        noisy = np.concatenate(inframes, axis=0)[None, :, :, :].astype(np.float32)
+        noise_map = np.full((1, 1, onnx_h, onnx_w), noise_sigma_01, dtype=np.float32)
+        feeds = {input_names[0]: noisy, input_names[1]: noise_map}
+        out = sess.run(output_names, feeds)[0]  # [1, 3, H, W]
+        out = np.clip(out, 0.0, 1.0)
+        den_bgr = chw_to_bgr_uint8(out[0], frames_bgr[0].shape[1], frames_bgr[0].shape[0])
+        den_frames_bgr.append(den_bgr)
+
+    return den_frames_bgr
+
+
+def write_side_by_side(frames_orig, frames_den, out_path, fps, label=True):
+    h, w = frames_orig[0].shape[:2]
+    os.makedirs(os.path.dirname(os.path.abspath(out_path)), exist_ok=True)
+    fourcc = cv2.VideoWriter_fourcc(*"mp4v")
+    writer = cv2.VideoWriter(out_path, fourcc, fps, (w * 2, h))
+    if not writer.isOpened():
+        raise RuntimeError("failed to create video writer: {}".format(out_path))
+    for orig, den in zip(frames_orig, frames_den):
+        canvas = np.concatenate([orig, den], axis=1)
+        if label:
+            cv2.putText(canvas, "Original", (16, 34), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 255), 2, cv2.LINE_AA)
+            cv2.putText(canvas, "ONNX Denoised", (w + 16, 34), cv2.FONT_HERSHEY_SIMPLEX, 1.0, (0, 255, 255), 2, cv2.LINE_AA)
+        writer.write(canvas)
+    writer.release()
+
+
+def main():
+    parser = argparse.ArgumentParser(description="FastDVDnet ONNX video inference side-by-side")
+    parser.add_argument("--onnx", type=str, default="./fastdvdnet_640x480.onnx")
+    parser.add_argument("--video", type=str, required=True, help="input mp4 video")
+    parser.add_argument("--noise_sigma", type=float, default=25.0, help="noise sigma 0-255")
+    parser.add_argument("--out_dir", type=str, default="./video_infer_results/onnx_test")
+    parser.add_argument("--max_frames", type=int, default=0, help="0 means all frames")
+    parser.add_argument("--no_label", action="store_true")
+    args = parser.parse_args()
+
+    x_shape = get_onnx_shapes(args.onnx)
+    _, _, onnx_h, onnx_w = x_shape
+    print("ONNX input shape: {}".format(x_shape))
+
+    sess = ort.InferenceSession(args.onnx, providers=["CPUExecutionProvider"])
+    input_names = [i.name for i in sess.get_inputs()]
+    output_names = [o.name for o in sess.get_outputs()]
+    print("providers:", sess.get_providers())
+    print("inputs:", [(n, list(i.shape)) for n, i in zip(input_names, sess.get_inputs())])
+    print("outputs:", [(n, list(o.shape)) for n, o in zip(output_names, sess.get_outputs())])
+
+    base = os.path.splitext(os.path.basename(args.video))[0]
+    out_path = os.path.join(args.out_dir, "{}_onnx_side_by_side.mp4".format(base))
+
+    t0 = time.time()
+    frames_bgr, fps, orig_w, orig_h = read_video(args.video, args.max_frames)
+    print("video: {}x{} @ {:.1f}fps, {} frames".format(orig_w, orig_h, fps, len(frames_bgr)))
+    print("onnx input: {}x{}".format(onnx_w, onnx_h))
+
+    sigma01 = args.noise_sigma / 255.0
+    den = denoise_onnx(frames_bgr, sigma01, sess, x_shape, input_names, output_names)
+    write_side_by_side(frames_bgr, den, out_path, fps, label=not args.no_label)
+    dt = time.time() - t0
+
+    print("[OK] {} -> {}".format(args.video, out_path))
+    print("     frames={} time={:.2f}s fps={:.2f}".format(len(frames_bgr), dt, len(frames_bgr) / max(dt, 0.001)))
+
+
+if __name__ == "__main__":
+    main()

fastDVDnet/res/people-sunset_axmodel_side_by_side.mp4

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

fastDVDnet/video/people-sunset.mp4

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