Upload folder using huggingface_hub

.gitattributes

@@ -34,3 +34,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
 *.axmodel filter=lfs diff=lfs merge=lfs -text
+python/sample_speech.pcm filter=lfs diff=lfs merge=lfs -text

cpp/src/rnnoise_ax.cpp

@@ -0,0 +1,115 @@
+// RNNoise AX SDK：用 AX Engine 替换原版 compute_rnn（网络推理），
+// 其余信号处理（biquad/FFT/pitch/合成）沿用原版 C 实现。
+#include "rnnoise_ax.hpp"
+
+#include "model_runner.hpp"
+
+#include <cstring>
+#include <mutex>
+#include <stdexcept>
+#include <vector>
+
+extern "C" {
+#include "denoise.h"
+#include "rnn.h"
+}
+
+namespace {
+
+// 单实例模型 runner（compute_rnn 无状态上下文可用，采用全局注册方式；
+// 同一时刻只允许一个 RNNoiseAX 实例执行推理）。
+std::mutex g_runner_mu;
+ModelRunner* g_ax_runner = nullptr;
+
+extern "C" void rnnoise_ax_set_runner(ModelRunner* runner) {
+    std::lock_guard<std::mutex> lk(g_runner_mu);
+    g_ax_runner = runner;
+}
+
+extern "C" void compute_rnn(const RNNoise* model, RNNState* rnn,
+                            float* gains, float* vad,
+                            const float* input, int arch) {
+    (void)model;
+    (void)arch;
+    ModelRunner* runner = nullptr;
+    {
+        std::lock_guard<std::mutex> lk(g_runner_mu);
+        runner = g_ax_runner;
+    }
+    if (runner == nullptr) {
+        throw std::runtime_error("compute_rnn: AX runner 未初始化");
+    }
+
+    std::vector<std::vector<float>> feeds = {
+        std::vector<float>(input, input + NB_FEATURES),
+        std::vector<float>(rnn->conv1_state,
+                           rnn->conv1_state + CONV1_STATE_SIZE),
+        std::vector<float>(rnn->conv2_state,
+                           rnn->conv2_state + CONV2_STATE_SIZE),
+        std::vector<float>(rnn->gru1_state,
+                           rnn->gru1_state + GRU1_OUT_SIZE),
+        std::vector<float>(rnn->gru2_state,
+                           rnn->gru2_state + GRU2_OUT_SIZE),
+        std::vector<float>(rnn->gru3_state,
+                           rnn->gru3_state + GRU3_OUT_SIZE),
+    };
+    std::vector<std::vector<float>> outs = runner->Run(feeds);
+
+    std::memcpy(gains, outs[0].data(), NB_BANDS * sizeof(float));
+    *vad = outs[1][0];
+    std::memcpy(rnn->conv1_state, outs[2].data(),
+                CONV1_STATE_SIZE * sizeof(float));
+    std::memcpy(rnn->conv2_state, outs[3].data(),
+                CONV2_STATE_SIZE * sizeof(float));
+    std::memcpy(rnn->gru1_state, outs[4].data(),
+                GRU1_OUT_SIZE * sizeof(float));
+    std::memcpy(rnn->gru2_state, outs[5].data(),
+                GRU2_OUT_SIZE * sizeof(float));
+    std::memcpy(rnn->gru3_state, outs[6].data(),
+                GRU3_OUT_SIZE * sizeof(float));
+}
+
+}  // namespace
+
+struct RNNoiseAX::Impl {
+    std::unique_ptr<ModelRunner> runner;
+    DenoiseState* state = nullptr;
+
+    explicit Impl(const std::string& model_path)
+        : runner(new ModelRunner(model_path)),
+          state(rnnoise_create(nullptr)) {
+        if (state == nullptr) {
+            throw std::runtime_error("rnnoise_create 失败");
+        }
+        rnnoise_ax_set_runner(runner.get());
+    }
+
+    ~Impl() {
+        rnnoise_ax_set_runner(nullptr);
+        if (state) {
+            rnnoise_destroy(state);
+        }
+    }
+};
+
+RNNoiseAX::RNNoiseAX(const std::string& model_path)
+    : impl_(new Impl(model_path)) {}
+
+RNNoiseAX::~RNNoiseAX() = default;
+
+void RNNoiseAX::Reset() {
+    if (!impl_) {
+        return;
+    }
+    rnnoise_ax_set_runner(nullptr);
+    rnnoise_destroy(impl_->state);
+    impl_->state = rnnoise_create(nullptr);
+    if (impl_->state == nullptr) {
+        throw std::runtime_error("rnnoise_create 失败");
+    }
+    rnnoise_ax_set_runner(impl_->runner.get());
+}
+
+float RNNoiseAX::ProcessFrame(float* out, const float* in) {
+    return rnnoise_process_frame(impl_->state, out, in);
+}

models/model.axmodel

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

models/model_meta.json

@@ -0,0 +1,140 @@
+{
+  "model_name": "rnnoise-ax650",
+  "framework": "pytorch->onnx",
+  "task": "noise_suppression",
+  "route": "general",
+  "opset": 13,
+  "inputs": [
+    {
+      "name": "features",
+      "shape": [
+        1,
+        65
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "conv1_mem",
+      "shape": [
+        1,
+        130
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "conv2_mem",
+      "shape": [
+        1,
+        256
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru1_s",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru2_s",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru3_s",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    }
+  ],
+  "outputs": [
+    {
+      "name": "gains",
+      "shape": [
+        1,
+        32
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "vad",
+      "shape": [
+        1,
+        1
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "conv1_mem_new",
+      "shape": [
+        1,
+        130
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "conv2_mem_new",
+      "shape": [
+        1,
+        256
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru1_s_new",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru2_s_new",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    },
+    {
+      "name": "gru3_s_new",
+      "shape": [
+        1,
+        384
+      ],
+      "dtype": "float32",
+      "layout": "NC"
+    }
+  ],
+  "stateful": true,
+  "frame_size": 480,
+  "sample_rate": 48000,
+  "preprocess": "48k PCM 帧(480) -> biquad HP -> FFT(960) -> 32 波段能量/DCT + pitch 特征 -> 65 维特征",
+  "input_domain": "float 等价 16-bit PCM（±32768 量级，不做归一化，与官方 demo 一致）",
+  "postprocess": "32 gains + vad -> gain 平滑/限幅 -> pitch filter -> 频谱合成 -> 480 样本",
+  "sdk_interface": {
+    "entry": "rnnoise_process_frame",
+    "args": "float32 帧(480) + 状态（内部维护）",
+    "returns": "float32 去噪帧 + vad"
+  },
+  "license": "isc"
+}

python/demo.py

@@ -0,0 +1,44 @@
+"""RNNoise AX650 降噪一键演示（复制即用）。
+
+板端：bash setup.sh && bash run.sh（自带 sample_speech.pcm 演示样本）。
+非 AX 主机：提示在板端运行后正常退出。
+"""
+import sys
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parents[1]
+
+try:
+    import axengine  # noqa: F401
+    AX_AVAILABLE = True
+except Exception:
+    AX_AVAILABLE = False
+
+
+def main() -> None:
+    if not AX_AVAILABLE:
+        print("当前主机没有 AX 芯片（pyaxengine 不可用），无法运行 NPU 推理。")
+        print("本交付包为 NPU 专用版，请在 AX650/AX630 板端执行：")
+        print("  bash setup.sh && bash run.sh")
+        return
+
+    import numpy as np
+    from rnnoise_ax650_sdk import RNNoiseDenoiser, dsp
+
+    model = ROOT / "models" / "model.axmodel"
+    sample = ROOT / "python" / "sample_speech.pcm"
+    denoiser = RNNoiseDenoiser(str(model))
+    pcm = np.fromfile(sample, dtype=np.float32)
+    out, vads = denoiser.process(pcm)
+    out_dir = ROOT / "output"
+    out_dir.mkdir(exist_ok=True)
+    out.astype(np.float32).tofile(out_dir / "out.pcm")
+    np.save(out_dir / "vad.npy", vads)
+    print(f"模型加载成功：{model}")
+    print(f"帧数: {vads.size}（每帧 10ms）")
+    print(f"语音存在比例: {float((vads > 0.5).mean()):.2f}")
+    print(f"输出已保存: {out_dir / 'out.pcm'}")
+
+
+if __name__ == "__main__":
+    main()

python/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+pyaxengine @ git+https://gh-proxy.com/https://github.com/AXERA-TECH/pyaxengine.git

python/rnnoise_ax650_sdk/README.md

@@ -0,0 +1,21 @@
+# rnnoise-ax650 Python SDK
+
+48kHz 单声道实时降噪（RNNoise，AX650 NPU3 编译）。
+
+- 输入：480 采样/帧 float32（16-bit PCM 等价域 ±32768，不做归一化）
+- 输出：去噪帧(480) + vad
+- 模型：6 输入（features + 5 个状态）/ 7 输出（gains/vad + 5 个新状态），
+  逐帧状态化推理，状态在 `RNNoiseDenoiser` 实例内维护
+- 前后处理：numpy 移植原版 rnnoise C 管线（biquad/FFT/带能量 DCT/pitch/
+  频谱合成），对照 `c_ref` 逐帧验证：特征 cosine≥0.995、去噪输出 cosine≥0.995
+
+```python
+from rnnoise_ax650_sdk import RNNoiseDenoiser
+import numpy as np
+
+denoiser = RNNoiseDenoiser("model.axmodel")
+frame = np.random.randn(480).astype(np.float32) * 3000  # 16-bit 域
+out, vad = denoiser.process_frame(frame)
+```
+
+开发版含 onnxruntime CPU 回退；发布版（NPU 专用）仅依赖 numpy + pyaxengine。

python/rnnoise_ax650_sdk/__init__.py

@@ -0,0 +1,4 @@
+from .inference import RNNoiseDenoiser
+from . import dsp, preprocess, postprocess
+
+__all__ = ["RNNoiseDenoiser", "dsp", "preprocess", "postprocess"]

python/rnnoise_ax650_sdk/dsp.py

@@ -0,0 +1,547 @@
+"""RNNoise 信号处理链的 numpy 移植（1:1 对应 origin/rnnoise/src 的 C 实现）。
+
+覆盖 denoise.c / pitch.c / kiss_fft / celt_lpc / rnnoise_tables 的浮点路径：
+  PCM 帧(480) -> biquad HP -> FFT(960) -> 32 波段能量/DCT + pitch -> 65 维特征
+  gains/vad -> gain 平滑/限幅 -> pitch filter -> 频谱合成 -> 480 样本
+
+约定：输入音频为 16-bit PCM 等价 float（±32768 量级，不做 /32768 归一化，
+与官方 rnnoise demo 一致）。所有运算尽量 float32，与 C float 语义对齐。
+"""
+from __future__ import annotations
+
+import numpy as np
+
+FRAME_SIZE = 480
+WINDOW_SIZE = 2 * FRAME_SIZE
+FREQ_SIZE = FRAME_SIZE + 1
+NB_BANDS = 32
+NB_FEATURES = 2 * NB_BANDS + 1
+
+PITCH_MIN_PERIOD = 60
+PITCH_MAX_PERIOD = 768
+PITCH_FRAME_SIZE = 960
+PITCH_BUF_SIZE = PITCH_MAX_PERIOD + PITCH_FRAME_SIZE
+
+EBAND20MS = np.array(
+    [0, 2, 4, 6, 8, 10, 12, 15, 18, 21, 24, 28, 32, 36, 41, 47, 53, 60,
+     68, 77, 87, 98, 110, 124, 140, 157, 176, 198, 223, 251, 282, 317, 356,
+     400], dtype=np.int32)
+
+SECOND_CHECK = np.array(
+    [0, 0, 3, 2, 3, 2, 5, 2, 3, 2, 3, 2, 5, 2, 3, 2], dtype=np.int32)
+
+
+def f32(x):
+    return np.asarray(x, dtype=np.float32)
+
+
+def make_half_window() -> np.ndarray:
+    """rnn_half_window（dump_rnnoise_tables.c 公式）。"""
+    i = (np.arange(FRAME_SIZE, dtype=np.float64) + 0.5)
+    s = np.sin(0.5 * np.pi * i / FRAME_SIZE)
+    w = np.sin(0.5 * np.pi * s * s)
+    return f32(w)
+
+
+HALF_WINDOW = make_half_window()
+
+
+def make_dct_table() -> np.ndarray:
+    """rnn_dct_table：行 i、列 j 为 cos((i+.5)*j*pi/32)，j==0 乘 sqrt(.5)。"""
+    i = np.arange(NB_BANDS, dtype=np.float64)[:, None]
+    j = np.arange(NB_BANDS, dtype=np.float64)[None, :]
+    t = np.cos((i + 0.5) * j * np.pi / NB_BANDS)
+    t[:, 0] *= np.sqrt(0.5)
+    return f32(t)
+
+
+DCT_TABLE = make_dct_table()
+
+
+def fft(x: np.ndarray) -> np.ndarray:
+    """forward FFT：kiss_fft 无缩放正变换（960 点），返回复数组。"""
+    return np.fft.fft(f32(x).astype(np.float64))
+
+
+def forward_transform(x: np.ndarray) -> np.ndarray:
+    """x[960] -> X[481]（kiss_fft 该 fork 正变换带 1/N 缩放）。"""
+    y = fft(x) / WINDOW_SIZE
+    return y[:FREQ_SIZE]
+
+
+def inverse_transform(y: np.ndarray) -> np.ndarray:
+    """X[481] -> x[960]（Hermitian 镜像 + 正变换实现逆变换）。"""
+    y = np.asarray(y)
+    n = WINDOW_SIZE
+    x = np.zeros(n, dtype=np.complex128)
+    x[:FREQ_SIZE] = y
+    x[FREQ_SIZE:] = np.conj(y[1:(n - FREQ_SIZE) + 1][::-1])
+    out = np.fft.fft(x)
+    res = np.empty(n, dtype=np.float64)
+    res[0] = out[0].real
+    res[1:] = out[n:0:-1].real
+    return res
+
+
+def apply_window(x: np.ndarray) -> np.ndarray:
+    x = x.copy()
+    x[:FRAME_SIZE] *= HALF_WINDOW
+    x[WINDOW_SIZE - 1:FRAME_SIZE - 1:-1] *= HALF_WINDOW
+    return x
+
+
+def compute_band_energy(X: np.ndarray) -> np.ndarray:
+    """X[481] 复数 -> bandE[32]。"""
+    X = np.asarray(X)
+    power = (X.real ** 2 + X.imag ** 2).astype(np.float64)
+    # C 实现用 sum[0..NB_BANDS+1]，sum[1] 和 sum[NB_BANDS] 修正后取 sum[1..NB_BANDS]
+    s = np.zeros(NB_BANDS + 2)
+    for i in range(NB_BANDS):
+        b0, b1 = int(EBAND20MS[i]), int(EBAND20MS[i + 1])
+        frac = (np.arange(b1 - b0, dtype=np.float64)) / (b1 - b0)
+        p = power[b0:b1]
+        s[i] += np.sum((1 - frac) * p)
+        s[i + 1] += np.sum(frac * p)
+    s[1] = (s[0] + s[1]) * 2.0 / 3.0
+    s[NB_BANDS] = (s[NB_BANDS] + s[NB_BANDS + 1]) * 2.0 / 3.0
+    return f32(s[1:NB_BANDS + 1])
+
+
+def compute_band_corr(X: np.ndarray, P: np.ndarray) -> np.ndarray:
+    X = np.asarray(X)
+    P = np.asarray(P)
+    prod = (X.real * P.real + X.imag * P.imag).astype(np.float64)
+    s = np.zeros(NB_BANDS + 2)
+    for i in range(NB_BANDS):
+        b0, b1 = int(EBAND20MS[i]), int(EBAND20MS[i + 1])
+        frac = (np.arange(b1 - b0, dtype=np.float64)) / (b1 - b0)
+        p = prod[b0:b1]
+        s[i] += np.sum((1 - frac) * p)
+        s[i + 1] += np.sum(frac * p)
+    s[1] = (s[0] + s[1]) * 2.0 / 3.0
+    s[NB_BANDS] = (s[NB_BANDS] + s[NB_BANDS + 1]) * 2.0 / 3.0
+    return f32(s[1:NB_BANDS + 1])
+
+
+def dct(inp: np.ndarray) -> np.ndarray:
+    """out[i] = sqrt(2/22) * sum_j in[j] * table[j, i]。"""
+    inp = f32(inp)
+    return f32(inp @ DCT_TABLE * np.sqrt(2.0 / 22.0))
+
+
+def rnn_biquad(x: np.ndarray, mem: np.ndarray, b, a) -> tuple[np.ndarray, np.ndarray]:
+    x = f32(x)
+    y = np.empty_like(x)
+    mem = mem.copy()
+    for i in range(x.size):
+        xi = float(x[i])
+        yi = xi + mem[0]
+        mem[0] = mem[1] + (b[0] * xi - a[0] * yi)
+        mem[1] = b[1] * xi - a[1] * yi
+        y[i] = yi
+    return y, mem
+
+
+def rnn_autocorr(x: np.ndarray, lag: int) -> np.ndarray:
+    """rnn_autocorr(overlap=0)：ac[k] = sum_i x[i]*x[i+k]。"""
+    n = x.size
+    x = f32(x)
+    ac = np.zeros(lag + 1, dtype=np.float64)
+    for k in range(lag + 1):
+        ac[k] = np.dot(x[:n - k].astype(np.float64), x[k:].astype(np.float64))
+    return ac
+
+
+def rnn_lpc(ac: np.ndarray, p: int) -> np.ndarray:
+    ac = np.asarray(ac, dtype=np.float64)
+    lpc = np.zeros(p, dtype=np.float64)
+    error = ac[0]
+    if ac[0] != 0:
+        for i in range(p):
+            rr = sum(lpc[j] * ac[i - j] for j in range(i)) + ac[i + 1]
+            r = -rr / error
+            lpc[i] = r
+            for j in range((i + 1) // 2):
+                tmp1 = lpc[j]
+                tmp2 = lpc[i - 1 - j]
+                lpc[j] = tmp1 + r * tmp2
+                lpc[i - 1 - j] = tmp2 + r * tmp1
+            error = error - r * r * error
+            if error < 0.001 * ac[0]:
+                break
+    return f32(lpc)
+
+
+def celt_fir5(x: np.ndarray, num: np.ndarray) -> np.ndarray:
+    """5 抽头 FIR：y[i] = x[i] + sum_j num[j]*x[i-1-j]。"""
+    x = f32(x)
+    num = f32(num)
+    n = x.size
+    y = np.empty(n, dtype=np.float32)
+    mem = np.zeros(5, dtype=np.float64)
+    for i in range(n):
+        xi = float(x[i])
+        s = xi + float(num[0]) * mem[0] + float(num[1]) * mem[1] + \
+            float(num[2]) * mem[2] + float(num[3]) * mem[3] + float(num[4]) * mem[4]
+        mem[4] = mem[3]
+        mem[3] = mem[2]
+        mem[2] = mem[1]
+        mem[1] = mem[0]
+        mem[0] = xi
+        y[i] = s
+    return y
+
+
+def rnn_pitch_downsample(x: np.ndarray) -> np.ndarray:
+    """1728 采样 -> 864 低通（2:1 抽取 + LPC 预加重）。"""
+    x = f32(x)
+    length = x.size
+    half = length // 2
+    x_lp = np.empty(half, dtype=np.float32)
+    x_lp[0] = 0.5 * (0.5 * float(x[1]) + float(x[0]))
+    for i in range(1, half):
+        x_lp[i] = 0.5 * (0.5 * (float(x[2 * i - 1]) + float(x[2 * i + 1])) + float(x[2 * i]))
+    ac = rnn_autocorr(x_lp, 4)
+    ac[0] *= 1.0001
+    for i in range(1, 5):
+        ac[i] -= ac[i] * (0.008 * i) * (0.008 * i)
+    lpc = rnn_lpc(ac, 4)
+    tmp = 1.0
+    for i in range(4):
+        tmp *= 0.9
+        lpc[i] = lpc[i] * tmp
+    lpc2 = np.zeros(5, dtype=np.float32)
+    c1 = 0.8
+    lpc2[0] = lpc[0] + 0.8
+    lpc2[1] = lpc[1] + c1 * lpc[0]
+    lpc2[2] = lpc[2] + c1 * lpc[1]
+    lpc2[3] = lpc[3] + c1 * lpc[2]
+    lpc2[4] = c1 * lpc[3]
+    return celt_fir5(x_lp, lpc2)
+
+
+def _find_best_pitch(xcorr: np.ndarray, y: np.ndarray, length: int, max_pitch: int):
+    """find_best_pitch（浮点路径），返回 best_pitch[2]。"""
+    xcorr = np.asarray(xcorr, dtype=np.float64)
+    y = np.asarray(y, dtype=np.float64)
+    Syy = 1.0 + np.dot(y[:length], y[:length])
+    best_num = [-1.0, -1.0]
+    best_den = [0.0, 0.0]
+    best_pitch = [0, 1]
+    for i in range(max_pitch):
+        if xcorr[i] > 0:
+            xcorr16 = xcorr[i] * 1e-12
+            num = xcorr16 * xcorr16
+            if num * best_den[1] > best_num[1] * Syy:
+                if num * best_den[0] > best_num[0] * Syy:
+                    best_num[1] = best_num[0]
+                    best_den[1] = best_den[0]
+                    best_pitch[1] = best_pitch[0]
+                    best_num[0] = num
+                    best_den[0] = Syy
+                    best_pitch[0] = i
+                else:
+                    best_num[1] = num
+                    best_den[1] = Syy
+                    best_pitch[1] = i
+        Syy += y[i + length] * y[i + length] - y[i] * y[i]
+        Syy = max(1.0, Syy)
+    return best_pitch
+
+
+def rnn_pitch_search(x_lp: np.ndarray, y: np.ndarray, length: int, max_pitch: int) -> int:
+    """rnn_pitch_search 返回 pitch（粗搜 + 细搜 + 伪插值）。"""
+    x_lp = f32(x_lp)
+    y = f32(y)
+    lag = length + max_pitch
+    len4 = length >> 2
+    x_lp4 = x_lp[0:length:2][:len4]
+    y_lp4 = y[0:lag:2][:(lag >> 2)]
+    xcorr = np.array([np.dot(x_lp4.astype(np.float64),
+                             y_lp4[i:i + len4].astype(np.float64))
+                      for i in range(max_pitch >> 2)], dtype=np.float64)
+    best_pitch = _find_best_pitch(xcorr, y_lp4, len4, max_pitch >> 2)
+    half = max_pitch >> 1
+    xcorr2 = np.zeros(half, dtype=np.float64)
+    x_lp64 = x_lp.astype(np.float64)
+    y64 = y.astype(np.float64)
+    for i in range(half):
+        if abs(i - 2 * best_pitch[0]) > 2 and abs(i - 2 * best_pitch[1]) > 2:
+            continue
+        s = np.dot(x_lp64[:length >> 1], y64[i:i + (length >> 1)])
+        xcorr2[i] = max(-1.0, s)
+    best_pitch = _find_best_pitch(xcorr2, y64, length >> 1, half)
+    bp = best_pitch[0]
+    if 0 < bp < half - 1:
+        a, b, c = xcorr2[bp - 1], xcorr2[bp], xcorr2[bp + 1]
+        if (c - a) > 0.7 * (b - a):
+            offset = 1
+        elif (a - c) > 0.7 * (b - c):
+            offset = -1
+        else:
+            offset = 0
+    else:
+        offset = 0
+    return 2 * bp - offset
+
+
+def _compute_pitch_gain(xy, xx, yy):
+    return xy / np.sqrt(1.0 + xx * yy)
+
+
+def rnn_remove_doubling(x: np.ndarray, maxperiod: int, minperiod: int, n: int,
+                        t0_in: int, prev_period: int, prev_gain: float):
+    """rnn_remove_doubling：返回 (pg, T0)。"""
+    x = f32(x)
+    minperiod0 = minperiod
+    maxperiod //= 2
+    minperiod //= 2
+    t0 = t0_in // 2
+    prev_period //= 2
+    n //= 2
+    x = x[maxperiod:]
+    if t0 >= maxperiod:
+        t0 = maxperiod - 1
+    T = T0 = t0
+    x64 = x.astype(np.float64)
+    xx = np.dot(x64[:n], x64[:n])
+    xy = np.dot(x64[:n], x64[T0:T0 + n])
+    yy_lookup = np.zeros(maxperiod + 1, dtype=np.float64)
+    yy_lookup[0] = xx
+    yy = xx
+    for i in range(1, maxperiod + 1):
+        yy = yy + float(x64[-i]) ** 2 - float(x64[n - i]) ** 2
+        yy_lookup[i] = max(0.0, yy)
+    yy = yy_lookup[T0]
+    best_xy, best_yy = xy, yy
+    g = g0 = _compute_pitch_gain(xy, xx, yy)
+    for k in range(2, 16):
+        T1 = (2 * T0 + k) // (2 * k)
+        if T1 < minperiod:
+            break
+        if k == 2:
+            T1b = T0 if T1 + T0 > maxperiod else T0 + T1
+        else:
+            T1b = (2 * int(SECOND_CHECK[k]) * T0 + k) // (2 * k)
+        xy2 = np.dot(x64[:n], x64[T1b:T1b + n])
+        xy = 0.5 * (xy + xy2)
+        yy = 0.5 * (yy_lookup[T1] + yy_lookup[T1b])
+        g1 = _compute_pitch_gain(xy, xx, yy)
+        if abs(T1 - prev_period) <= 1:
+            cont = prev_gain
+        elif abs(T1 - prev_period) <= 2 and 5 * k * k < T0:
+            cont = 0.5 * prev_gain
+        else:
+            cont = 0.0
+        thresh = max(0.3, 0.7 * g0 - cont)
+        if T1 < 3 * minperiod:
+            thresh = max(0.4, 0.85 * g0 - cont)
+        elif T1 < 2 * minperiod:
+            thresh = max(0.5, 0.9 * g0 - cont)
+        if g1 > thresh:
+            best_xy, best_yy = xy, yy
+            T = T1
+            g = g1
+    best_xy = max(0.0, best_xy)
+    pg = 1.0 if best_yy <= best_xy else best_xy / (best_yy + 1.0)
+    xcorr = np.zeros(3)
+    for k in range(3):
+        lag = T + k - 1
+        xcorr[k] = np.dot(x64[:n], x64[lag:lag + n])
+    if (xcorr[2] - xcorr[0]) > 0.7 * (xcorr[1] - xcorr[0]):
+        offset = 1
+    elif (xcorr[0] - xcorr[2]) > 0.7 * (xcorr[1] - xcorr[2]):
+        offset = -1
+    else:
+        offset = 0
+    if pg > g:
+        pg = g
+    T0 = 2 * T + offset
+    if T0 < minperiod0:
+        T0 = minperiod0
+    return float(pg), int(T0)
+
+
+def interp_band_gain(bandE: np.ndarray) -> np.ndarray:
+    bandE = np.asarray(bandE, dtype=np.float64)
+    g = np.zeros(FREQ_SIZE)
+    for i in range(1, NB_BANDS):
+        b0, b1 = int(EBAND20MS[i]), int(EBAND20MS[i + 1])
+        frac = (np.arange(b1 - b0, dtype=np.float64)) / (b1 - b0)
+        g[b0:b1] = (1 - frac) * bandE[i - 1] + frac * bandE[i]
+    g[:int(EBAND20MS[1])] = bandE[0]
+    g[int(EBAND20MS[NB_BANDS]):int(EBAND20MS[NB_BANDS + 1])] = bandE[NB_BANDS - 1]
+    return f32(g)
+
+
+def rnn_pitch_filter(X, P, Ex, Ep, Exp, g):
+    """rnn_pitch_filter：就地修改 X[481]。"""
+    X = np.asarray(X, dtype=np.complex128)
+    P = np.asarray(P, dtype=np.complex128)
+    Ex = np.asarray(Ex, dtype=np.float64)
+    Ep = np.asarray(Ep, dtype=np.float64)
+    Exp = np.asarray(Exp, dtype=np.float64)
+    g = np.asarray(g, dtype=np.float64)
+    r = np.zeros(NB_BANDS)
+    for i in range(NB_BANDS):
+        if Exp[i] > g[i]:
+            r[i] = 1.0
+        else:
+            r[i] = (Exp[i] ** 2) * (1 - g[i] ** 2) / (0.001 + g[i] ** 2 * (1 - Exp[i] ** 2))
+            r[i] = np.sqrt(min(1.0, max(0.0, r[i])))
+        r[i] *= np.sqrt(Ex[i] / (1e-8 + Ep[i]))
+    rf = interp_band_gain(r)
+    X += rf * P
+    newE = compute_band_energy(X)
+    norm = np.sqrt(Ex / (1e-8 + newE))
+    normf = interp_band_gain(norm)
+    X *= normf
+    return X
+
+
+class RNNoiseState:
+    """对应 DenoiseState：维护全部帧间状态。"""
+
+    def __init__(self):
+        self.analysis_mem = np.zeros(FRAME_SIZE, dtype=np.float32)
+        self.synthesis_mem = np.zeros(FRAME_SIZE, dtype=np.float32)
+        self.pitch_buf = np.zeros(PITCH_BUF_SIZE, dtype=np.float32)
+        self.last_gain = 0.0
+        self.last_period = 0
+        self.mem_hp_x = np.zeros(2, dtype=np.float32)
+        self.lastg = np.zeros(NB_BANDS, dtype=np.float32)
+        self.delayed_X = np.zeros(FREQ_SIZE, dtype=np.complex128)
+        self.delayed_P = np.zeros(FREQ_SIZE, dtype=np.complex128)
+        self.delayed_Ex = np.zeros(NB_BANDS, dtype=np.float32)
+        self.delayed_Ep = np.zeros(NB_BANDS, dtype=np.float32)
+        self.delayed_Exp = np.zeros(NB_BANDS, dtype=np.float32)
+
+
+def rnn_frame_analysis(st: RNNoiseState, inp: np.ndarray):
+    """返回 (X[481], Ex[32])。"""
+    x = np.concatenate([st.analysis_mem, f32(inp)])
+    st.analysis_mem = f32(inp).copy()
+    x = apply_window(x)
+    X = forward_transform(x)
+    Ex = compute_band_energy(X)
+    return X, Ex
+
+
+def compute_frame_features(st: RNNoiseState, inp: np.ndarray):
+    """返回 (silence, X, P, Ex, Ep, Exp, features)。features 为空时清为 0。"""
+    X, Ex = rnn_frame_analysis(st, inp)
+    st.pitch_buf = np.concatenate([st.pitch_buf[FRAME_SIZE:], f32(inp)])
+    pre = st.pitch_buf
+    pitch_buf_lp = rnn_pitch_downsample(pre)
+    x_lp = pitch_buf_lp[(PITCH_MAX_PERIOD >> 1):]
+    y = pitch_buf_lp
+    pitch_index = rnn_pitch_search(
+        x_lp, y, PITCH_FRAME_SIZE, PITCH_MAX_PERIOD - 3 * PITCH_MIN_PERIOD)
+    pitch_index = PITCH_MAX_PERIOD - pitch_index
+    gain, pitch_index = rnn_remove_doubling(
+        st.pitch_buf, PITCH_MAX_PERIOD, PITCH_MIN_PERIOD, PITCH_FRAME_SIZE,
+        pitch_index, st.last_period, st.last_gain)
+    st.last_period = pitch_index
+    st.last_gain = gain
+    p = np.array([
+        st.pitch_buf[PITCH_BUF_SIZE - WINDOW_SIZE - pitch_index + i]
+        for i in range(WINDOW_SIZE)], dtype=np.float32)
+    p = apply_window(p)
+    P = forward_transform(p)
+    Ep = compute_band_energy(P)
+    Exp = compute_band_corr(X, P)
+    Exp = Exp / np.sqrt(0.001 + Ex * Ep)
+    features = np.zeros(NB_FEATURES, dtype=np.float32)
+    features[NB_BANDS:2 * NB_BANDS] = dct(Exp)
+    features[2 * NB_BANDS] = 0.01 * (pitch_index - 300)
+    logMax = -2.0
+    follow = -2.0
+    Ly = np.zeros(NB_BANDS)
+    E = 0.0
+    for i in range(NB_BANDS):
+        Ly[i] = np.log10(1e-2 + float(Ex[i]))
+        Ly[i] = max(logMax - 7, max(follow - 1.5, Ly[i]))
+        logMax = max(logMax, Ly[i])
+        follow = max(follow - 1.5, Ly[i])
+        E += float(Ex[i])
+    if E < 0.04:
+        features[:] = 0.0
+        return 1, X, P, Ex, Ep, Exp, features
+    features[:NB_BANDS] = dct(Ly)
+    features[0] -= 12.0
+    features[1] -= 4.0
+    return 0, X, P, Ex, Ep, Exp, features
+
+
+def frame_synthesis(st: RNNoiseState, y) -> np.ndarray:
+    x = inverse_transform(y)
+    x = apply_window(x)
+    out = f32(x[:FRAME_SIZE] + st.synthesis_mem)
+    st.synthesis_mem = f32(x[FRAME_SIZE:])
+    return out
+
+
+def analyze_frame(st: RNNoiseState, inp: np.ndarray) -> dict:
+    """C 端 rnnoise_process_frame 前半：biquad + 特征分析。
+
+    返回 dict(silence, features, X, P, Ex, Ep, Exp)。会推进 st 的
+    analysis_mem / pitch_buf / last_period / last_gain 等 DSP 状态。
+    """
+    a_hp = np.array([-1.99599, 0.99600], dtype=np.float32)
+    b_hp = np.array([-2, 1], dtype=np.float32)
+    x, st.mem_hp_x = rnn_biquad(f32(inp), st.mem_hp_x, b_hp, a_hp)
+    silence, X, P, Ex, Ep, Exp, features = compute_frame_features(st, x)
+    return {"silence": silence, "features": features,
+            "X": X, "P": P, "Ex": Ex, "Ep": Ep, "Exp": Exp}
+
+
+def synthesize_frame(st: RNNoiseState, ana: dict, gains, vad):
+    """C 端 rnnoise_process_frame 后半：pitch filter + 增益 + 频谱合成。
+
+    gains 为 None 表示静音帧（跳过模型相关部分，vad 记 0）。
+    返回 (out_frame, vad_prob)。需在 analyze_frame 之后调用。
+    """
+    silence = ana["silence"]
+    X, P, Ex, Ep, Exp = ana["X"], ana["P"], ana["Ex"], ana["Ep"], ana["Exp"]
+    if not silence and gains is not None:
+        gains = f32(gains).reshape(-1)
+        st.delayed_X = rnn_pitch_filter(
+            st.delayed_X, st.delayed_P, st.delayed_Ex, st.delayed_Ep,
+            st.delayed_Exp, gains)
+        for i in range(NB_BANDS):
+            alpha = 0.6
+            gains[i] = max(gains[i], alpha * st.lastg[i])
+            st.lastg[i] = min(1.0, gains[i] * (st.delayed_Ex[i] + 1e-3) / (Ex[i] + 1e-3))
+        gf = interp_band_gain(gains)
+        st.delayed_X = st.delayed_X * gf
+    out = frame_synthesis(st, st.delayed_X)
+    st.delayed_X = X
+    st.delayed_P = P
+    st.delayed_Ex = Ex
+    st.delayed_Ep = Ep
+    st.delayed_Exp = Exp
+    vad_prob = 0.0 if (silence or gains is None) else float(np.asarray(vad).reshape(-1)[0])
+    return out, vad_prob
+
+
+def process_frame(st: RNNoiseState, inp: np.ndarray, gains, vad):
+    """完整一帧（C 端 rnnoise_process_frame 等价），返回 (out, vad_prob)。"""
+    ana = analyze_frame(st, inp)
+    if ana["silence"]:
+        return synthesize_frame(st, ana, None, 0.0)
+    return synthesize_frame(st, ana, gains, vad)
+
+
+def features_from_pcm(pcm: np.ndarray) -> np.ndarray:
+    """批量：48k f32 PCM（16-bit 域）-> (T, 65) 特征矩阵（含 silence 清零逻辑）。"""
+    st = RNNoiseState()
+    feats = []
+    pcm = f32(pcm)
+    for t in range(0, pcm.size - FRAME_SIZE + 1, FRAME_SIZE):
+        frame = pcm[t:t + FRAME_SIZE]
+        a_hp = np.array([-1.99599, 0.99600], dtype=np.float32)
+        b_hp = np.array([-2, 1], dtype=np.float32)
+        x, st.mem_hp_x = rnn_biquad(frame, st.mem_hp_x, b_hp, a_hp)
+        _, _, _, _, _, _, features = compute_frame_features(st, x)
+        feats.append(features.copy())
+    return np.stack(feats)

python/rnnoise_ax650_sdk/example.py

@@ -0,0 +1,63 @@
+"""RNNoise 降噪示例：处理一段 48k 单声道音频，输出去噪结果。
+
+用法:
+  python example.py --model model.axmodel --input in.pcm [--output-dir out]
+
+输入格式：48kHz f32le PCM（16-bit 等价域，±32768，不做归一化）；
+也可传 16-bit PCM .wav（wave 标准库自动解码为 ±32768 域）。
+"""
+import argparse
+import sys
+import wave
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parents[1]))
+
+from rnnoise_ax650_sdk import RNNoiseDenoiser, dsp  # noqa: E402
+
+
+def load_pcm(path: Path) -> np.ndarray:
+    if path.suffix.lower() == ".wav":
+        with wave.open(str(path), "rb") as w:
+            assert w.getframerate() == 48000, "仅支持 48kHz WAV"
+            assert w.getsampwidth() == 2, "仅支持 16-bit PCM WAV"
+            raw = w.readframes(w.getnframes())
+        return np.frombuffer(raw, dtype="<i2").astype(np.float32)
+    return np.fromfile(path, dtype=np.float32)
+
+
+def write_wav(path: Path, pcm: np.ndarray, sr: int = 48000) -> None:
+    pcm = np.clip(pcm, -32768.0, 32767.0).astype(np.int16)
+    with wave.open(str(path), "wb") as w:
+        w.setnchannels(1)
+        w.setsampwidth(2)
+        w.setframerate(sr)
+        w.writeframes(pcm.tobytes())
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="RNNoise 48k 实时降噪示例")
+    parser.add_argument("--model", required=True, help="model.axmodel 路径")
+    parser.add_argument("--input", required=True, help="48k f32 PCM 或 16-bit WAV")
+    parser.add_argument("--output-dir", default="output")
+    args = parser.parse_args()
+
+    pcm = load_pcm(Path(args.input))
+    print(f"input: {pcm.size / 48000:.2f}s ({pcm.size // dsp.FRAME_SIZE} 帧)")
+    denoiser = RNNoiseDenoiser(args.model)
+    out, vads = denoiser.process(pcm)
+    out_dir = Path(args.output_dir)
+    out_dir.mkdir(parents=True, exist_ok=True)
+    out.astype(np.float32).tofile(out_dir / "out.pcm")
+    write_wav(out_dir / "out.wav", out)
+    np.save(out_dir / "vad.npy", vads)
+    print(f"backend: {denoiser.backend}")
+    print(f"frames: {vads.size}  vad_mean: {float(vads.mean()):.4f}")
+    print(f"output RMS: {float(np.sqrt((out ** 2).mean())):.1f}")
+    print(f"saved to: {out_dir}")
+
+
+if __name__ == "__main__":
+    main()

python/rnnoise_ax650_sdk/inference.py

@@ -0,0 +1,77 @@
+"""RNNoise AX650 推理会话（NPU 专用发布版：无 onnxruntime/torch 回退）。"""
+import numpy as np
+
+from . import dsp
+
+DEFAULT_PROVIDER = "AxEngineExecutionProvider"
+
+INPUT_NAMES = ["features", "conv1_mem", "conv2_mem",
+               "gru1_s", "gru2_s", "gru3_s"]
+INPUT_SHAPES = {"features": (1, 65), "conv1_mem": (1, 130),
+                "conv2_mem": (1, 256), "gru1_s": (1, 384),
+                "gru2_s": (1, 384), "gru3_s": (1, 384)}
+OUTPUT_NAMES = ["gains", "vad", "conv1_mem_new", "conv2_mem_new",
+                "gru1_s_new", "gru2_s_new", "gru3_s_new"]
+_STATE_INPUTS = ["conv1_mem", "conv2_mem", "gru1_s", "gru2_s", "gru3_s"]
+
+
+class RNNoiseDenoiser:
+    """48k 单声道实时降噪器（AX 芯片端到端，无 CPU 回退）。"""
+
+    def __init__(self, model_path, providers=None):
+        try:
+            import axengine as axe
+        except ImportError as exc:
+            raise RuntimeError(
+                "SDK 为 NPU 专用发布版，仅支持在 AX 芯片上运行；请先安装 "
+                "requirements.txt 并在板端执行（无 onnxruntime/torch 回退）"
+            ) from exc
+        self.session = axe.InferenceSession(
+            model_path, providers=providers or [DEFAULT_PROVIDER])
+        self.backend = "axengine"
+        self.input_names = [i.name for i in self.session.get_inputs()]
+        self.output_names = [o.name for o in self.session.get_outputs()]
+        self.reset()
+
+    def reset(self):
+        self.st = dsp.RNNoiseState()
+        self._states = {k: np.zeros(INPUT_SHAPES[k], dtype=np.float32)
+                        for k in _STATE_INPUTS}
+
+    def process_frame(self, frame):
+        frame = np.asarray(frame, dtype=np.float32).reshape(-1)
+        if frame.size != dsp.FRAME_SIZE:
+            raise ValueError(f"帧长必须为 {dsp.FRAME_SIZE}，实际 {frame.size}")
+        ana = dsp.analyze_frame(self.st, frame)
+        if ana["silence"]:
+            out, _ = dsp.synthesize_frame(self.st, ana, None, 0.0)
+            return out, 0.0
+        feeds = {
+            "features": np.ascontiguousarray(
+                ana["features"][None, :].astype(np.float32)),
+        }
+        feeds.update({k: np.ascontiguousarray(v)
+                      for k, v in self._states.items()})
+        outs = self.session.run(None, feeds)
+        out_idx = {n: i for i, n in enumerate(self.output_names)}
+        gains = outs[out_idx["gains"]]
+        vad = outs[out_idx["vad"]]
+        for k in _STATE_INPUTS:
+            self._states[k] = np.asarray(
+                outs[out_idx[k + "_new"]], dtype=np.float32)
+        out, vad = dsp.synthesize_frame(self.st, ana, gains, vad)
+        return out, float(vad)
+
+    def process(self, pcm):
+        pcm = np.asarray(pcm, dtype=np.float32)
+        if pcm.ndim == 1:
+            n = pcm.size // dsp.FRAME_SIZE
+            frames = pcm[:n * dsp.FRAME_SIZE].reshape(n, dsp.FRAME_SIZE)
+        else:
+            frames = pcm.reshape(-1, dsp.FRAME_SIZE)
+        outs, vads = [], []
+        for fr in frames:
+            o, v = self.process_frame(fr)
+            outs.append(o)
+            vads.append(v)
+        return np.concatenate(outs), np.asarray(vads, dtype=np.float32)

python/rnnoise_ax650_sdk/postprocess.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+def postprocess(ana, gains, vad, state):
+    """模型输出(gains/vad) + 分析结果 -> (去噪帧(480,), vad)。
+    对应原版 rnnoise_process_frame 的 pitch filter / 增益平滑 / 频谱合成部分。"""
+    from .dsp import synthesize_frame
+    return synthesize_frame(state, ana,
+                            np.asarray(gains, dtype=np.float32),
+                            np.asarray(vad, dtype=np.float32))

python/rnnoise_ax650_sdk/preprocess.py

@@ -0,0 +1,9 @@
+import numpy as np
+
+def preprocess(frame, state):
+    """48k PCM 帧(480, float32, 16-bit 域) -> (features(1,65), analysis)。
+    对应原版 rnnoise_process_frame 的 biquad + 特征分析部分。
+    state 为 dsp.RNNoiseState 实例（帧间状态，由 SDK 内部维护）。"""
+    from .dsp import analyze_frame
+    ana = analyze_frame(state, np.asarray(frame, dtype=np.float32).reshape(-1))
+    return ana["features"][None, :].astype(np.float32), ana

python/rnnoise_ax650_sdk/requirements.txt

@@ -0,0 +1,2 @@
+numpy
+pyaxengine @ git+https://gh-proxy.com/https://github.com/AXERA-TECH/pyaxengine.git

python/sample_speech.pcm

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

reports/compile_report.md

@@ -0,0 +1,7 @@
+# Compile Report
+
+- image: docker-registry.aitsw.axera-tech.com/pulsar2:20260810-temp-0d4427ff
+- target: AX650
+- input: features:1x65,conv1_mem:1x130,conv2_mem:1x256,gru1_s:1x384,gru2_s:1x384,gru3_s:1x384
+- src_dtype: FP32
+- size: 3314.4 KB

reports/export_report.md

@@ -0,0 +1,14 @@
+# Export Report
+
+- ONNX: export/model.onnx (opset 13, 静态 shape, 6 输入 / 7 输出)
+- 输入域: 与官方 demo 一致，float 值等价 16-bit PCM（±32768 量级），不做 /32768 归一化
+- 权重来源: 官方 rnnoise_data.c（float 数组 + 稀疏重建 + diag），
+  tanh/sigmoid 复刻 C 端有理逼近
+- Torch(参考) ↔ ONNX 对分（198 帧真实语音特征序列）:
+  - gains cosine: 1.000000
+  - vad cosine:   1.000000
+  - gains MAE:    1.42e-07
+- C 库 compute_rnn ↔ Torch 参考对分（198 帧）: gains cosine 0.999999, vad 0.9999995
+- 校准数据: calib_data/<tensor>.tar.gz，来自真实语音（speech/speech-echo/
+  speech-reverb + 合成噪声混合 6dB），每输入 40 帧特征+状态轨迹（real 业务数据）
+- 状态语义: 逐帧推理，conv1/conv2 mem 各保留 2 帧，GRU 状态 384x3

reports/runonboard_report.md

@@ -0,0 +1,26 @@
+# Run On Board Report（RNNoise AX650）
+
+- board: root@10.126.35.203（AX650C / MC50，aarch64）
+- model: compile/model.axmodel（U16 链路，NPU3，3.31MB）
+- engine: axengine 2.12.0s（板端本地推理，非远程代理）；C++ 链接 /soc/lib/libax_engine.so
+- 测试音频: sample_speech.pcm（48k f32，16-bit 域，1 秒=100 帧，语音+白噪声 6dB）
+
+## Python SDK（rnnoise_ax650_sdk，numpy DSP 移植）
+
+- 每帧延迟: 60.8 ms（numpy DSP 为主，含每帧 axengine 调用；帧预算 10ms——实时路径请用 C++）
+- 输出 vs c_ref（原版 C 全管线参考）: cosine 0.9973，MAE 243.8
+- vad vs c_ref: cosine 0.9998
+- 内存: 推理前后 549→541 MB（无显著增长）
+
+## C++ SDK（原版 C 信号处理 + AX Engine compute_rnn 替换）
+
+- 板上 cmake configure + make 通过（AX_RUNTIME_ROOT=/tmp/rnnoise_ax650/axrt，头文件 mc50）
+- 每帧延迟: 2.85 ms（含 6 输入/7 输出拷贝 + NPU 0.3ms；实时预算 10ms ✅）
+- 输出 vs c_ref: cosine 0.9820，MAE 819.6
+- 内存: 539→541 MB
+
+## 结论
+
+- Python / C++ SDK 板端端到端 NPU 推理通过（输出 cosine ≥ 0.98）
+- 实时降噪（10ms/帧）用 C++ SDK；Python SDK 适合离线批处理/原型验证
+- SIMULATE 阶段已确认模型层 gains cosine 0.9991 ≥ 0.99

reports/simulate_report.md

@@ -0,0 +1,22 @@
+# SIMULATE Report
+
+- board: 10.126.35.203
+- frames: 198
+- 方法：逐帧状态化远程推理（ONNX FP32 参考 vs AXMODEL），远程每帧 ~0.3ms NPU
+- 量化：U16 链路（MatMul/Conv/Add/Mul/Div/Sub/Concat/Clip/Slice，S8 权重），MinMax，calibration_size=30
+- 指标：
+
+| 张量 | cosine | MAE |
+|------|--------|-----|
+| gains | 0.999122 | 0.017231 |
+| vad | 0.999962 | 0.001985 |
+| conv1_mem_new | 0.999127 | 0.001900 |
+| conv2_mem_new | 0.997568 | 0.020142 |
+| gru1_s_new | 0.995698 | 0.030715 |
+| gru2_s_new | 0.994793 | 0.036976 |
+| gru3_s_new | 0.992189 | 0.050399 |
+
+- gains max_abs_diff: 0.275927
+- vad max_abs_diff: 0.078959
+
+结论：gains cosine 0.9991 ≥ 0.99 ✅，GRU 状态 0.992-0.996 ✅，SIMULATE 通过。

run.sh

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== 运行推理 ==="
+if command -v python3 >/dev/null 2>&1; then PY=python3; else PY=python; fi
+"$PY" python/demo.py
+# ./cpp/build/model_example models/model.axmodel

setup.sh

@@ -0,0 +1,21 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+echo "=== 安装依赖 ==="
+PIP_INDEX_URL="${PIP_INDEX_URL:-https://mirrors.aliyun.com/pypi/simple/}"
+if command -v python3 >/dev/null 2>&1; then PY=python3; else PY=python; fi
+if "$PY" -m pip --version >/dev/null 2>&1; then
+  "$PY" -m pip install -i "$PIP_INDEX_URL" -r python/requirements.txt
+elif command -v pip >/dev/null 2>&1; then
+  pip install -i "$PIP_INDEX_URL" -r python/requirements.txt
+else
+  echo "⚠ 未找到 pip：本机仅用于查看/自测，NPU 推理请在 AX 板端执行（板端自带 pip）。"
+fi
+
+echo "C++ SDK: 请先安装 AX650 BSP SDK，然后："
+# export AX_RUNTIME_ROOT=/path/to/axruntime
+# mkdir -p cpp/build && cd cpp/build
+# cmake .. -DCMAKE_TOOLCHAIN_FILE=${AX_RUNTIME_ROOT}/toolchain.cmake
+# make -j$(nproc)
+
+echo "✅ 环境准备完成"