Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ 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
+models/model.axmodel filter=lfs diff=lfs merge=lfs -text
+test_audio/mix.wav filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+build/
+CMakeFiles/
+CMakeCache.txt
+*.egg-info/

README.md

@@ -0,0 +1,68 @@
+---
+license: apache-2.0
+pipeline_tag: audio-to-audio
+tags:
+- axmodel
+- axera
+- gcrn
+- speech-enhancement
+---
+# GCRN 语音增强（AX650 NPU3）
+
+GCRN（Graph Convolutional Recurrent Network）单声道语音增强模型，输入 16 kHz 噪声语音，
+输出同长增强语音。本包为 AX650 / NPU3 量化部署版：
+
+- 精度：AXMODEL 与 ONNX 参考余弦相似度 **0.9992**（增强波形余弦 0.9997）
+- 速度：AX650 板端 **RTF 0.029**（9.77 秒音频约 0.28 秒处理完）
+- 大小：AXMODEL **27.6 MB**（ONNX 38 MB）
+
+## 快速开始（两步）
+
+### 1. 安装环境
+
+```bash
+bash setup.sh
+```
+
+### 2. 跑推理
+
+```bash
+bash run.sh
+```
+
+脚本会自动选择后端：板端（有 axengine）跑 NPU 模型，普通电脑自动用 ONNX 模型演示。
+输出为 `enhanced.wav`，增强前后的对比音频可以自己听一下。
+
+## 目录说明
+
+| 目录 | 用途 |
+|------|------|
+| `models/` | AXMODEL 模型 + `model_meta.json` |
+| `python/` | Python SDK（axengine / onnxruntime 双后端）|
+| `cpp/` | C++ SDK（AX Engine runtime，aarch64 交叉编译）|
+| `model_convert/` | 导出、校准、Pulsar2 编译全套可复现脚本 |
+| `reports/` | 导出/编译/仿真/板端验证报告 |
+| `test_audio/` | 自带 9.77 秒测试音频 |
+
+## 在自己的代码里用
+
+```python
+from gcrn_sdk import GCRNDenoiser
+
+denoiser = GCRNDenoiser("models/model.axmodel")
+report = denoiser.enhance_file("test_audio/mix.wav", "enhanced.wav")
+print(report)  # 含 RTF 等性能指标
+```
+
+## 常见问题
+
+**Q: import 报错找不到 axengine？**
+A: 说明当前不在 AX 板端。代码会自动用 ONNX 模型演示；要在 NPU 上跑，需在 AX650 板端
+安装匹配的 axengine wheel（见 `setup.sh` 输出提示）。
+
+**Q: 想自己重新编译 AXMODEL？**
+A: 进入 `model_convert/` 按 README 操作，Pulsar2 会从 ONNX 重新量化编译。
+原始编译使用 Docker 镜像 `pulsar2:7.0-lite`，配置为 NPU3 + U16 高精度模式。
+
+**Q: 输入音频有什么要求？**
+A: 16 kHz、单声道、16-bit PCM WAV；更长音频会自动按 4 秒分块处理并拼接。

config.json

@@ -0,0 +1 @@
+{}

models/model.axmodel

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

models/model_meta.json

@@ -0,0 +1,46 @@
+{
+  "model_name": "gcrn_fixed_4sec",
+  "framework": "onnx",
+  "source": "gcrn_fixed_4sec.onnx",
+  "source_sha256": "9e8e0acd13126c9d5d19aae6f83f230a16c8914f100744153c78c58920d1ff4a",
+  "inputs": [
+    {
+      "name": "stft_input",
+      "shape": [
+        1,
+        2,
+        401,
+        161
+      ],
+      "dtype": "float32",
+      "layout": "NCHW"
+    }
+  ],
+  "outputs": [
+    {
+      "name": "stft_output",
+      "shape": [
+        1,
+        2,
+        401,
+        161
+      ],
+      "dtype": "float32"
+    }
+  ],
+  "opset": 12,
+  "onnxsim_cosine_min": 1.0,
+  "preprocess": {
+    "description": "STFT of 16 kHz mono waveform -> [1,2,401,161] (batch, real/imag, time, freq)",
+    "sample_rate": 16000,
+    "duration_sec": 4.0,
+    "n_fft": 320,
+    "hop_length": 160,
+    "win_length": 320,
+    "center": true,
+    "window": "hamming(sym=True)"
+  },
+  "notes": [
+    "\u8f93\u5165\u4e3a STFT \u590d\u6570\u8c31\uff08\u5b9e\u90e8/\u865a\u90e8\uff09\uff0c\u65e0 mean/std \u5f52\u4e00\u5316"
+  ]
+}

python/README.md

@@ -0,0 +1,41 @@
+# GCRN Python SDK
+
+GCRN 语音增强 Python 推理 SDK。模型输入 16 kHz 单声道噪声语音的 STFT 谱
+`[1, 2, 401, 161]`（4 秒分块），输出增强谱，再还原为增强波形。
+
+## 安装
+
+```bash
+pip install -r requirements.txt
+```
+
+`axengine` 需要 AX650 板端（或带 AX runtime 的主机）；普通电脑可以装 `onnxruntime`
+后用 ONNX 模型调试。
+
+## 快速使用
+
+```bash
+python3 demo.py --model ../models/model.axmodel --input ../test_audio/mix.wav --output enhanced.wav
+```
+
+## API
+
+```python
+from gcrn_sdk import GCRNDenoiser
+
+denoiser = GCRNDenoiser("models/model.axmodel")   # .onnx 自动走 onnxruntime
+report = denoiser.enhance_file("noisy.wav", "enhanced.wav")
+print(report["real_time_factor"])
+
+# 直接处理 int16 PCM：
+pcm = ...  # np.int16
+enhanced = denoiser.enhance(pcm)
+```
+
+## 预处理说明
+
+- 输入要求：16 kHz、单声道、16-bit PCM WAV；
+- 分块：4 秒（64000 样本），不足补零，逐块增强后拼接；
+- STFT：`n_fft=320, hop=160, win=320`，hamming（sym）窗，与模型训练端一致；
+- 模型边界：`stft_input [1,2,401,161] float32` -> `stft_output [1,2,401,161] float32`
+  （布局为 batch, real/imag, time, freq）。

python/demo.py

@@ -0,0 +1,35 @@
+#!/usr/bin/env python3
+# coding: utf-8
+"""GCRN AX650 语音增强示例：noisy.wav -> enhanced.wav"""
+
+import argparse
+import sys
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+
+from gcrn_sdk import GCRNDenoiser
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="GCRN speech enhancement on AX650")
+    ap.add_argument("--model", default="models/model.axmodel", help="axmodel (或 onnx)")
+    ap.add_argument("--input", default="test_audio/mix.wav", help="16kHz mono noisy wav")
+    ap.add_argument("--output", default="enhanced.wav", help="输出 wav")
+    ap.add_argument("--report", default="gcrn_report.json", help="性能报告输出")
+    args = ap.parse_args()
+
+    denoiser = GCRNDenoiser(args.model)
+    report = denoiser.enhance_file(args.input, args.output)
+    denoiser.save_report(report, args.report)
+    print(f"input={args.input}")
+    print(f"output={args.output}")
+    print(
+        f"elapsed={report['elapsed_seconds']:.3f}s "
+        f"audio={report['audio_seconds']:.3f}s "
+        f"rtf={report['real_time_factor']:.4f}"
+    )
+
+
+if __name__ == "__main__":
+    main()

python/gcrn_sdk/__init__.py

@@ -0,0 +1,6 @@
+# coding: utf-8
+"""GCRN 语音增强 AX SDK。"""
+
+from .inference import GCRNDenoiser
+
+__all__ = ["GCRNDenoiser"]

python/gcrn_sdk/audio.py

@@ -0,0 +1,103 @@
+# coding: utf-8
+"""GCRN 依赖极简的音频预处理：16kHz 单声道 WAV <-> STFT [1,2,401,161]。
+
+与 GCRN.AXERA 的 board_inference/audio.py 保持一致（hamming sym 窗 + numpy rfft）。
+"""
+from __future__ import annotations
+
+import wave
+from pathlib import Path
+
+import numpy as np
+
+SAMPLE_RATE = 16000
+CHUNK_SAMPLES = 4 * SAMPLE_RATE
+N_FFT = 320
+HOP_LENGTH = 160
+WIN_LENGTH = 320
+
+
+def read_wav(path: str | Path) -> tuple[np.ndarray, int]:
+    with wave.open(str(path), "rb") as source:
+        if source.getnchannels() != 1 or source.getsampwidth() != 2:
+            raise ValueError(f"expected mono 16-bit PCM WAV: {path}")
+        sample_rate = source.getframerate()
+        samples = np.frombuffer(
+            source.readframes(source.getnframes()), dtype=np.int16
+        ).copy()
+    return samples, sample_rate
+
+
+def write_wav(path: str | Path, samples: np.ndarray, sample_rate: int) -> None:
+    values = np.asarray(samples, dtype=np.float32).reshape(-1)
+    pcm = np.clip(values, -1.0, 1.0)
+    pcm = np.rint(pcm * 32767.0).astype(np.int16)
+    path = Path(path)
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with wave.open(str(path), "wb") as output:
+        output.setnchannels(1)
+        output.setsampwidth(2)
+        output.setframerate(sample_rate)
+        output.writeframes(pcm.tobytes())
+
+
+def _symmetric_hamming(size: int) -> np.ndarray:
+    index = np.arange(size, dtype=np.float32)
+    return (0.54 - 0.46 * np.cos(2.0 * np.pi * index / (size - 1))).astype(
+        np.float32
+    )
+
+
+def chunks(samples: np.ndarray) -> list[tuple[np.ndarray, int]]:
+    """int16 PCM -> 4 秒 float32 chunk 序列 [(chunk, valid_samples)]。"""
+    values = np.asarray(samples, dtype=np.float32).reshape(-1) / 32768.0
+    if values.size == 0:
+        raise ValueError("input WAV is empty")
+    result = []
+    for start in range(0, values.size, CHUNK_SAMPLES):
+        end = min(start + CHUNK_SAMPLES, values.size)
+        valid = end - start
+        chunk = np.zeros(CHUNK_SAMPLES, dtype=np.float32)
+        chunk[:valid] = values[start:end]
+        result.append((chunk, valid))
+    return result
+
+
+def stft(chunk: np.ndarray) -> np.ndarray:
+    """4 秒波形 -> [1, 2, 401, 161]（batch, real/imag, time, freq）。"""
+    signal = np.asarray(chunk, dtype=np.float32).reshape(-1)
+    if signal.size != CHUNK_SAMPLES:
+        raise ValueError(f"expected {CHUNK_SAMPLES} samples, got {signal.size}")
+    pad = N_FFT // 2
+    signal = np.pad(signal, (pad, pad), mode="constant")
+    frame_count = 1 + (signal.size - WIN_LENGTH) // HOP_LENGTH
+    frames = np.lib.stride_tricks.sliding_window_view(signal, WIN_LENGTH)[
+        ::HOP_LENGTH
+    ][:frame_count]
+    spectrum = np.fft.rfft(frames * _symmetric_hamming(WIN_LENGTH)[None, :], axis=1)
+    value = np.stack((spectrum.real, spectrum.imag), axis=0)
+    return value.astype(np.float32)[None, ...]
+
+
+def istft(value: np.ndarray) -> np.ndarray:
+    """[1,2,401,161] 增强谱 -> 64000 个 float32 样本。"""
+    output = np.asarray(value, dtype=np.float32)
+    if output.shape != (1, 2, 401, 161):
+        raise ValueError(f"unexpected GCRN output shape: {output.shape}")
+    value = output[0]
+    spectrum = value[0].astype(np.float64) + 1j * value[1].astype(np.float64)
+    frames = np.fft.irfft(spectrum, n=N_FFT, axis=1)
+    window = _symmetric_hamming(WIN_LENGTH).astype(np.float64)
+    frames *= window[None, :]
+
+    output_length = N_FFT + HOP_LENGTH * (frames.shape[0] - 1)
+    waveform = np.zeros(output_length, dtype=np.float64)
+    window_sum = np.zeros(output_length, dtype=np.float64)
+    for index, frame in enumerate(frames):
+        start = index * HOP_LENGTH
+        waveform[start : start + N_FFT] += frame
+        window_sum[start : start + N_FFT] += window * window
+    valid = window_sum > np.finfo(np.float64).eps
+    waveform[valid] /= window_sum[valid]
+    pad = N_FFT // 2
+    return waveform[pad:-pad].astype(np.float32)

python/gcrn_sdk/inference.py

@@ -0,0 +1,86 @@
+# coding: utf-8
+"""GCRN 语音增强推理：4 秒 chunk STFT -> axmodel -> ISTFT -> 拼接输出。"""
+from __future__ import annotations
+
+import json
+import time
+from pathlib import Path
+
+import numpy as np
+
+from .audio import (
+    SAMPLE_RATE,
+    chunks,
+    istft,
+    read_wav,
+    stft,
+    write_wav,
+)
+from .runtime import InferenceSession, first_output
+
+INPUT_NAME = "stft_input"
+OUTPUT_NAME = "stft_output"
+INPUT_SHAPE = (1, 2, 401, 161)
+
+
+class GCRNDenoiser:
+    """AX650 GCRN 语音增强器。默认 .axmodel + axengine。"""
+
+    def __init__(self, model_path: str | Path, backend: str | None = None):
+        self.session = InferenceSession(model_path, backend)
+        if len(self.session.inputs) != 1 or self.session.inputs[0].shape != INPUT_SHAPE:
+            raise RuntimeError(f"unexpected GCRN input metadata: {self.session.inputs}")
+        if len(self.session.outputs) != 1 or self.session.outputs[0].shape != INPUT_SHAPE:
+            raise RuntimeError(f"unexpected GCRN output metadata: {self.session.outputs}")
+        self.input_name = self.session.inputs[0].name
+
+    def _warmup(self) -> None:
+        feed = stft(np.zeros(64000, dtype=np.float32))
+        first_output(self.session, self.session.run({self.input_name: feed}))
+
+    def enhance_chunk(self, chunk: np.ndarray) -> np.ndarray:
+        feed = stft(chunk)
+        outputs = self.session.run({self.input_name: feed})
+        output = np.asarray(first_output(self.session, outputs), dtype=np.float32)
+        return istft(output)
+
+    def enhance(self, pcm: np.ndarray) -> np.ndarray:
+        """int16 PCM -> 增强后 float32 波形（与输入等长）。"""
+        self._warmup()
+        enhanced = [
+            self.enhance_chunk(chunk)
+            for chunk, _valid in chunks(pcm)
+        ]
+        return np.concatenate(enhanced)[: pcm.size]
+
+    def enhance_file(
+        self, input_path: str | Path, output_path: str | Path
+    ) -> dict:
+        """输入 16kHz 单声道 WAV，输出增强 WAV + 性能报告 dict。"""
+        samples, sample_rate = read_wav(input_path)
+        if sample_rate != SAMPLE_RATE:
+            raise ValueError(
+                f"GCRN requires {SAMPLE_RATE} Hz audio, got {sample_rate}"
+            )
+        start = time.perf_counter()
+        enhanced = self.enhance(samples)
+        elapsed = time.perf_counter() - start
+        write_wav(output_path, enhanced, sample_rate)
+        audio_seconds = samples.size / sample_rate
+        report = {
+            "backend": self.session.backend,
+            "model": str(self.session.path),
+            "input": str(input_path),
+            "output": str(output_path),
+            "input_samples": int(samples.size),
+            "output_samples": int(enhanced.size),
+            "elapsed_seconds": round(elapsed, 4),
+            "audio_seconds": round(audio_seconds, 4),
+            "real_time_factor": round(elapsed / audio_seconds, 4),
+        }
+        return report
+
+    def save_report(self, report: dict, path: str | Path) -> None:
+        path = Path(path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        path.write_text(json.dumps(report, indent=2) + "\n", encoding="utf-8")

python/gcrn_sdk/runtime.py

@@ -0,0 +1,114 @@
+# coding: utf-8
+"""axengine / onnxruntime 推理会话封装。"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class TensorInfo:
+    name: str
+    shape: tuple[int, ...]
+    dtype: np.dtype
+
+
+def _numpy_dtype(value: Any) -> np.dtype:
+    text = str(value).lower()
+    mapping = (
+        (("tensor(float)", "float32", "fp32", "f32"), np.float32),
+        (("tensor(float16)", "float16", "fp16", "f16"), np.float16),
+        (("tensor(int64)", "int64", "s64"), np.int64),
+        (("tensor(int32)", "int32", "s32"), np.int32),
+        (("tensor(uint16)", "uint16", "u16"), np.uint16),
+        (("tensor(uint8)", "uint8", "u8"), np.uint8),
+    )
+    for aliases, dtype in mapping:
+        if any(alias in text for alias in aliases):
+            return np.dtype(dtype)
+    raise ValueError(f"unsupported runtime tensor dtype: {value}")
+
+
+def _tensor_info(value: Any) -> TensorInfo:
+    shape = getattr(value, "shape", None)
+    if shape is None:
+        shape = getattr(value, "dims", None)
+    if shape is None or any(dim is None for dim in shape):
+        raise ValueError(f"dynamic or missing tensor shape for {value.name}: {shape}")
+    dtype = getattr(value, "dtype", None)
+    if dtype is None:
+        dtype = getattr(value, "type", None)
+    return TensorInfo(
+        name=value.name,
+        shape=tuple(int(dim) for dim in shape),
+        dtype=_numpy_dtype(dtype),
+    )
+
+
+class InferenceSession:
+    """.axmodel -> axengine；.onnx -> onnxruntime CPU。"""
+
+    def __init__(self, model_path: str | Path, backend: str | None = None):
+        self.path = Path(model_path)
+        if not self.path.is_file():
+            raise FileNotFoundError(self.path)
+        if backend is None:
+            backend = "axengine" if self.path.suffix == ".axmodel" else "onnx"
+        self.backend = backend
+        if backend == "axengine":
+            try:
+                import axengine
+            except ImportError as error:
+                raise RuntimeError(
+                    "axengine is unavailable; run this backend on an AXERA board"
+                ) from error
+            self._session = axengine.InferenceSession(str(self.path))
+        elif backend == "onnx":
+            try:
+                import onnxruntime as ort
+            except ImportError as error:
+                raise RuntimeError("onnxruntime is required for --backend onnx") from error
+            options = ort.SessionOptions()
+            options.inter_op_num_threads = 1
+            options.intra_op_num_threads = 1
+            self._session = ort.InferenceSession(
+                str(self.path),
+                sess_options=options,
+                providers=["CPUExecutionProvider"],
+            )
+        else:
+            raise ValueError(f"unsupported backend: {backend}")
+
+        self.inputs = [_tensor_info(value) for value in self._session.get_inputs()]
+        self.outputs = [_tensor_info(value) for value in self._session.get_outputs()]
+        self.input_by_name = {value.name: value for value in self.inputs}
+
+    def run(self, feed: dict[str, np.ndarray]) -> dict[str, np.ndarray]:
+        missing = [value.name for value in self.inputs if value.name not in feed]
+        if missing:
+            raise KeyError(f"missing inputs for {self.path.name}: {missing}")
+        prepared = {
+            name: np.ascontiguousarray(np.asarray(feed[name], dtype=meta.dtype))
+            for name, meta in self.input_by_name.items()
+        }
+        values = self._session.run(None, prepared)
+        if isinstance(values, dict):
+            return {name: np.asarray(value) for name, value in values.items()}
+        if not isinstance(values, (list, tuple)):
+            values = [values]
+        if len(values) != len(self.outputs):
+            raise RuntimeError(
+                f"unexpected output count from {self.path.name}: "
+                f"{len(values)} != {len(self.outputs)}"
+            )
+        return {
+            meta.name: np.asarray(value)
+            for meta, value in zip(self.outputs, values)
+        }
+
+
+def first_output(session: InferenceSession, outputs: dict[str, np.ndarray]) -> np.ndarray:
+    return outputs[session.outputs[0].name]

python/requirements.txt

@@ -0,0 +1,6 @@
+# GCRN AX Python SDK 依赖
+# 运行时（板端 / 带 AX runtime 主机）：
+axengine>=0.1.3        # pyaxengine：.axmodel NPU 推理
+numpy>=1.24
+# 仅主机调试（无 NPU 时用 onnx 模型 + onnxruntime）：
+onnxruntime>=1.16

reports/compile_report.md

@@ -0,0 +1,14 @@
+# Compile Report
+
+- image: pulsar2:7.0-lite
+- target: AX650 (AX650N_CHIP)
+- npu_mode: NPU3
+- input: stft_input:1x2x401x161 (FP32)
+- model: model.onnx -> model.axmodel
+- quant: default U16, Pow/Sqrt/Div/LSTM FP32, conv_bias FP32, MinMax, 25 calib samples
+- macs: 9,799,365,320 (~9.8 GMACs)
+- max_cycle: 38,038,900
+- end-to-end quant cosine (Pulsar2 precision table): 0.99963 (stft_output)
+- axmodel size: 28 MB (source onnx 38 MB, compression 0.74x)
+- compile time: ~1h51m (LSTM unrolled to ~300k ops; host heavily loaded)
+- highest_mix_precision: false

reports/export_report.md

@@ -0,0 +1,8 @@
+# Export Report
+
+- ONNX: model.onnx (simplified from gcrn_fixed_4sec.onnx)
+- Input: stft_input [1, 2, 401, 161] float32
+- Output: stft_output [1, 2, 401, 161] float32
+- Opset: 12
+- onnxsim cosine (vs source, 25 windows): min=1.000000 mean=1.000000
+- Calibration data: stft_input.tar.gz (25 samples)

reports/performance_report.md

@@ -0,0 +1,41 @@
+# GCRN AX650 性能报告
+
+## 模型概况
+
+| 项目 | 数值 |
+|------|------|
+| 模型 | GCRN 语音增强（4 秒固定输入）|
+| 输入/输出 | `[1, 2, 401, 161]` float32 |
+| 计算量 | 9.80 GMACs |
+| 量化 | U16（LSTM/Pow/Sqrt/Div/conv_bias FP32）|
+| ONNX 大小 | 38 MB |
+| AXMODEL 大小 | 27.6 MB |
+
+## 精度（ONNX vs AXMODEL，8 个样本）
+
+| 指标 | mean ± std |
+|------|-----------|
+| cosine_similarity | 0.99922 ± 0.00039（min 0.99850）|
+| MAE | 0.00888 ± 0.00066 |
+| max_abs_diff | 1.37 ± 0.87 |
+| 增强波形 cosine（首样本）| 0.99974 |
+
+## 板端延迟（AX650N，NPU3 三核）
+
+测试音频 9.77 秒（156302 样本，4 个 4 秒分块 + 尾部）。
+
+| 语言 | 处理总耗时 | RTF |
+|------|-----------|-----|
+| Python（axengine）| 0.28 s | 0.0287 |
+| C++（axengine）| ~28 s（含直接 DFT 预处理）| 2.9 |
+
+说明：
+- Python RTF 0.029 为完整链路（STFT + NPU + ISTFT + 拼接），NPU 单模型推理约 0.064 s/块；
+- C++ 耗时主要花在 320 点直接 DFT（每块 401×161×320 复数乘加），若接入 FFT 库可降到亚秒级；
+- 板端内存占用：模型 + 双 SDK 运行峰值 < 512 MB（板总内存 3.4 GB）。
+
+## 编译信息
+
+- Pulsar2 镜像：`pulsar2:7.0-lite`
+- 目标：AX650 / NPU3；`highest_mix_precision=false`
+- 编译耗时：约 1 小时 51 分（LSTM 展开约 30 万算子）

reports/runonboard_report.md

@@ -0,0 +1,20 @@
+# RunOnBoard Report
+
+- board: AX650N_CHIP（Engine 2.12.0s, Compiler 7.0 6b1bcdf8）
+- model: model.axmodel (NPU3, triple core)
+
+## Python SDK (gcrn_sdk, axengine backend)
+- input: test_audio/mix.wav (16 kHz mono, 9.77s, 156302 samples)
+- output: enhanced_board.wav
+- elapsed: 0.280s  audio: 9.769s  RTF: 0.0287
+- board-vs-host ONNX enhanced waveform cosine: 0.999674, MAE 0.001599
+- import gcrn_sdk: OK; model input/output [1,2,401,161] float32
+
+## C++ SDK (gcrn_example, cross-compiled aarch64 + BSP)
+- fixed: AX_SYS_Init before AX_ENGINE_Init; WAV 16-bit read/write; [c,t,f] row-major layout; braced-init vector size
+- output: enhanced_cpp.wav (156302 samples)
+- cpp-vs-python board waveform cosine: 0.999997, MAE 0.000063
+- runtime: ~28s (direct DFT 320-point pre/post in C++, no FFT lib on board)
+
+## 结论
+- Python/C++ 双 SDK 在 AX650 板端跑通，输出一致，端到端音频质量与 ONNX 参考几乎一致。

reports/simulate_report.md

@@ -0,0 +1,8 @@
+# Simulate Report
+
+- Method: board axengine（AX650N 板端实测）
+- Samples: 8
+- cosine_similarity: mean=0.999222 std=0.000389 min=0.998504
+- mae: mean=0.008880 std=0.000658 min=0.007749
+- max_abs_diff: mean=1.373579 std=0.870593 min=0.490195
+- audio_level: {"enhanced_waveform_cosine": 0.9997435882461786, "enhanced_waveform_mae": 0.0013857042649760842}

run.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== 运行 GCRN 语音增强推理 ==="
+if python3 -c "import axengine" 2>/dev/null; then
+    python3 python/demo.py --model models/model.axmodel --input test_audio/mix.wav --output enhanced.wav
+else
+    echo "未检测到 axengine（本机无 NPU），自动使用 ONNX 模型在 CPU 上演示："
+    python3 python/demo.py --model model_convert/model.onnx --input test_audio/mix.wav --output enhanced.wav
+fi
+
+echo "输出音频: enhanced.wav"

setup.sh

@@ -0,0 +1,25 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== 安装 Python 依赖 ==="
+pip install numpy>=1.24 onnxruntime>=1.16
+
+echo "=== 尝试安装 axengine（NPU 推理；仅 AX650 板端可用）==="
+if python3 -c "import axengine" 2>/dev/null; then
+    echo "axengine 已就绪"
+else
+    if pip install axengine 2>/dev/null; then
+        echo "axengine 安装成功"
+    else
+        echo "⚠ 本机无法安装 axengine（通常因为不是 AX 板端环境）。"
+        echo "  板端请先安装匹配的 axengine wheel，例如："
+        echo "  pip3 install axengine-<版本>-py3-none-any.whl"
+    fi
+fi
+
+echo "=== C++ SDK（可选）==="
+echo "  需要 AX650 BSP SDK（含 ax_engine 头文件与库），然后："
+echo "  mkdir -p cpp/build && cd cpp/build"
+echo "  cmake .. -DAX650_SDK_ROOT=/path/to/bsp/out && make -j$(nproc)"
+
+echo "✅ 环境准备完成"

test_audio/mix.wav

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