feat: SDK 更新 — 韵律/时长/Postnet 走 NPU，PNCA 解码 CPU，postnet 分块修复

sdk/include/kantts.hpp

@@ -59,14 +59,10 @@ public:
     std::vector<float> SynthesizeSymbols(const std::vector<std::string>& symbols);
 
 private:
-    std::unique_ptr<ModelSession> enc_, voc_;
+    std::unique_ptr<ModelSession> enc_, voc_, pe_, dur_, post_, dec_;
+    std::string model_dir_;
     Weights w_;
     std::unique_ptr<Frontend> frontend_;
 };
 
-// host 管线（供内部/测试使用）
-std::vector<float> HostPredictors(const Weights& w, const std::vector<float>& text_hid,
-                                  const std::vector<float>& spk_hid,
-                                  const std::vector<float>& emo_hid, int T);
-
 }  // namespace kantts

sdk/src/kantts.cpp

@@ -109,21 +109,6 @@ void Conv1dSame(const std::vector<float>& x, const std::vector<float>& wgt,
         }
 }
 
-void DepthwiseShift(const std::vector<float>& x, const std::vector<float>& wgt,
-                    int T, int C, int K, int lp, int rp, std::vector<float>& y) {
-    y.assign(T * C, 0.0f);
-    for (int c = 0; c < C; ++c)
-        for (int t = 0; t < T; ++t) {
-            float acc = 0;
-            for (int k = 0; k < K; ++k) {
-                int tt = t - lp + k;
-                if (tt < 0 || tt >= T) continue;
-                acc += x[tt * C + c] * wgt[c * K + k];
-            }
-            y[t * C + c] = acc;
-        }
-}
-
 void LstmCell(const std::vector<float>& x, const std::vector<float>& w_ih,
               const std::vector<float>& w_hh, const std::vector<float>& b_ih,
               const std::vector<float>& b_hh, std::vector<float>& h, std::vector<float>& c,
@@ -146,109 +131,6 @@ void LstmCell(const std::vector<float>& x, const std::vector<float>& w_ih,
     }
 }
 
-void Blstm(const std::vector<float>& x, const Weights& w, const std::string& pre,
-           int T, int in_d, int units, std::vector<float>& y) {
-    const auto& wih = w.Get(pre + "_blstm_w_ih");
-    const auto& whh = w.Get(pre + "_blstm_w_hh");
-    const auto& bih = w.Get(pre + "_blstm_b_ih");
-    const auto& bhh = w.Get(pre + "_blstm_b_hh");
-    const auto& wihr = w.Get(pre + "_blstm_w_ih_r");
-    const auto& whhr = w.Get(pre + "_blstm_w_hh_r");
-    const auto& bihr = w.Get(pre + "_blstm_b_ih_r");
-    const auto& bhhr = w.Get(pre + "_blstm_b_hh_r");
-    std::vector<float> hf(units, 0), cf(units, 0), hb(units, 0), cb(units, 0);
-    y.assign(T * 2 * units, 0.0f);
-    std::vector<float> xi(in_d);
-    for (int t = 0; t < T; ++t) {
-        std::copy(x.begin() + t * in_d, x.begin() + (t + 1) * in_d, xi.begin());
-        LstmCell(xi, wih, whh, bih, bhh, hf, cf, units);
-        std::copy(hf.begin(), hf.end(), y.begin() + t * 2 * units);
-    }
-    for (int t = T - 1; t >= 0; --t) {
-        std::copy(x.begin() + t * in_d, x.begin() + (t + 1) * in_d, xi.begin());
-        LstmCell(xi, wihr, whhr, bihr, bhhr, hb, cb, units);
-        std::copy(hb.begin(), hb.end(), y.begin() + t * 2 * units + units);
-    }
-}
-
-std::vector<float> FsmnEncoder(const std::vector<float>& x, const Weights& w,
-                               const std::string& pre, int T, int C, const std::vector<int>& shift) {
-    std::vector<float> cur = x;
-    int layers = 0;
-    while (w.Has(pre + "_ffn" + std::to_string(layers) + "_w1")) ++layers;
-    for (int i = 0; i < layers; ++i) {
-        int mid = (int)w.Shape(pre + "_ffn" + std::to_string(i) + "_w1")[0];
-        std::vector<float> c1;
-        Conv1dSame(cur, w.Get(pre + "_ffn" + std::to_string(i) + "_w1"),
-                   w.Get(pre + "_ffn" + std::to_string(i) + "_b1"), T, C, mid, 1, c1);
-        for (auto& v : c1) v = std::max(v, 0.0f);
-        int out_c = (int)w.Shape(pre + "_ffn" + std::to_string(i) + "_w2")[0];
-        std::vector<float> c2;
-        Conv1dSame(c1, w.Get(pre + "_ffn" + std::to_string(i) + "_w2"),
-                   w.Get(pre + "_ffn" + std::to_string(i) + "_b2"), T, mid, out_c, 1, c2);
-        int fsize = (int)w.Shape(pre + "_mem" + std::to_string(i) + "_conv")[2];
-        int sh = shift.empty() ? 0 : shift[i];
-        int lp = (fsize - 1) / 2 + (sh > 0 ? sh : 0);
-        int rp = (fsize - 1) / 2 - (sh > 0 ? sh : 0);
-        std::vector<float> mem;
-        DepthwiseShift(c2, w.Get(pre + "_mem" + std::to_string(i) + "_conv"), T, out_c, fsize,
-                       lp, rp, mem);
-        for (int t = 0; t < T; ++t)
-            for (int c = 0; c < out_c; ++c) mem[t * out_c + c] += c2[t * out_c + c];
-        if (out_c == C)
-            for (int t = 0; t < T; ++t)
-                for (int c = 0; c < out_c; ++c) mem[t * out_c + c] += cur[t * C + c];
-        cur = mem;
-        C = out_c;
-    }
-    return cur;
-}
-
-std::vector<float> VarFsmnRnnPredictor(const std::vector<float>& x, const Weights& w,
-                                       const std::string& pre, int T, int in_d) {
-    std::vector<float> h = FsmnEncoder(x, w, pre, T, in_d, {0, 0, 0});
-    std::vector<float> bh;
-    Blstm(h, w, pre, T, 128, 128, bh);
-    std::vector<float> out(T);
-    const auto& fw = w.Get(pre + "_fc_w");
-    const auto& fb = w.Get(pre + "_fc_b");
-    for (int t = 0; t < T; ++t) {
-        float acc = fb[0];
-        for (int k = 0; k < 256; ++k) acc += bh[t * 256 + k] * fw[0 * 256 + k];
-        out[t] = acc;
-    }
-    return out;
-}
-
-std::vector<float> DurationAr(const std::vector<float>& cond, const Weights& w, int T, int in_d) {
-    std::vector<float> h0(128, 0), c0(128, 0), h1(128, 0), c1(128, 0);
-    std::vector<float> x(1, 0.0f), out(T);
-    const auto& p0w = w.Get("dur_pre0_w");
-    const auto& p0b = w.Get("dur_pre0_b");
-    const auto& p1w = w.Get("dur_pre1_w");
-    const auto& p1b = w.Get("dur_pre1_b");
-    const auto& fw = w.Get("dur_fc_w");
-    const auto& fb = w.Get("dur_fc_b");
-    std::vector<float> inp, tmp;
-    for (int t = 0; t < T; ++t) {
-        Matmul(x, p0w, p0b, 1, 1, 128, inp);
-        for (auto& v : inp) v = std::max(v, 0.0f);
-        Matmul(inp, p1w, p1b, 1, 128, 128, tmp);
-        for (auto& v : tmp) v = std::max(v, 0.0f);
-        std::vector<float> xin(tmp);
-        xin.insert(xin.end(), cond.begin() + t * in_d, cond.begin() + (t + 1) * in_d);
-        LstmCell(xin, w.Get("dur_lstm_w_ih0"), w.Get("dur_lstm_w_hh0"), w.Get("dur_lstm_b_ih0"),
-                 w.Get("dur_lstm_b_hh0"), h0, c0, 128);
-        LstmCell(h0, w.Get("dur_lstm_w_ih1"), w.Get("dur_lstm_w_hh1"), w.Get("dur_lstm_b_ih1"),
-                 w.Get("dur_lstm_b_hh1"), h1, c1, 128);
-        float acc = fb[0];
-        for (int k = 0; k < 128; ++k) acc += h1[k] * fw[0 * 128 + k];
-        x[0] = std::max(acc, 0.0f);
-        out[t] = x[0];
-    }
-    return out;
-}
-
 }  // namespace
 
 void Weights::Load(const std::string& dir) {
@@ -408,102 +290,6 @@ Frontend::EncInput Frontend::Encode(const std::string& symbol_seq) {
 
 namespace {
 
-// build_memory：text/spk/emo (T,32) → memory (M,160) + lr_len + durations
-void BuildMemory(const std::vector<float>& text_hid, const std::vector<float>& spk_hid,
-                 const std::vector<float>& emo_hid, const Weights& w, int T,
-                 std::vector<float>& memory, int& lr_len, std::vector<float>& durations) {
-    std::vector<float> var_in(T * 96);
-    for (int t = 0; t < T; ++t)
-        for (int c = 0; c < 32; ++c) {
-            var_in[t * 96 + c] = text_hid[t * 32 + c];
-            var_in[t * 96 + 32 + c] = spk_hid[t * 32 + c];
-            var_in[t * 96 + 64 + c] = emo_hid[t * 32 + c];
-        }
-    auto pitch = VarFsmnRnnPredictor(var_in, w, "pitch", T, 96);
-    auto energy = VarFsmnRnnPredictor(var_in, w, "energy", T, 96);
-    if (std::getenv("KANTTS_DUMP_ENC")) {
-        {
-            std::ofstream f("/tmp/kt/enc_pitch.bin", std::ios::binary);
-            f.write((const char*)pitch.data(), pitch.size() * 4);
-        }
-        {
-            std::ofstream f("/tmp/kt/enc_energy.bin", std::ios::binary);
-            f.write((const char*)energy.data(), energy.size() * 4);
-        }
-    }
-    std::vector<float> pe, ee;
-    Conv1dSame(pitch, w.Get("pitch_emb_w"), w.Get("pitch_emb_b"), T, 1, 32, 9, pe);
-    Conv1dSame(energy, w.Get("energy_emb_w"), w.Get("energy_emb_b"), T, 1, 32, 9, ee);
-    std::vector<float> aug(T * 32);
-    for (int t = 0; t < T * 32; ++t) aug[t] = text_hid[t] + pe[t] + ee[t];
-    if (std::getenv("KANTTS_DUMP_ENC")) {
-        std::ofstream f("/tmp/kt/enc_aug.bin", std::ios::binary);
-        f.write((const char*)aug.data(), aug.size() * 4);
-    }
-    std::vector<float> cond(T * 96);
-    for (int t = 0; t < T; ++t)
-        for (int c = 0; c < 32; ++c) {
-            cond[t * 96 + c] = aug[t * 32 + c];
-            cond[t * 96 + 32 + c] = spk_hid[t * 32 + c];
-            cond[t * 96 + 64 + c] = emo_hid[t * 32 + c];
-        }
-    auto log_dur = DurationAr(cond, w, T, 96);
-    if (std::getenv("KANTTS_DUMP_ENC")) {
-        std::ofstream f("/tmp/kt/enc_logdur.bin", std::ios::binary);
-        f.write((const char*)log_dur.data(), log_dur.size() * 4);
-    }
-    durations.resize(T);
-    int sum = 0;
-    std::vector<int> reps(T);
-    for (int t = 0; t < T; ++t) {
-        durations[t] = std::exp(log_dur[t]) - 1.0f;
-        reps[t] = (int)(durations[t] + 0.5f);
-        sum += reps[t];
-    }
-    int pad = 3 - sum % 3;
-    if (pad == 3) pad = 0;
-    int P = sum + pad;
-    // LR text/spk/emo
-    auto expand = [&](const std::vector<float>& src, std::vector<float>& dst) {
-        dst.assign(P * 32, 0.0f);
-        int pos = 0;
-        for (int t = 0; t < T; ++t)
-            for (int r = 0; r < reps[t]; ++r) {
-                std::copy(src.begin() + t * 32, src.begin() + (t + 1) * 32,
-                          dst.begin() + (pos++) * 32);
-            }
-    };
-    std::vector<float> lr_text, lr_emo, lr_spk;
-    expand(aug, lr_text);
-    expand(emo_hid, lr_emo);
-    expand(spk_hid, lr_spk);
-    // dur position encoder
-    std::vector<float> rc(T + 1, 0);
-    for (int t = 0; t < T; ++t) rc[t + 1] = rc[t] + reps[t];
-    std::vector<float> lr_pos(P * 32, 0.0f);
-    for (int p = 0; p < P; ++p) {
-        int ph = 0;
-        for (int t = 0; t < T; ++t)
-            if (rc[t] <= p && p < rc[t + 1]) { ph = p - rc[t] + 1; break; }
-        for (int c = 0; c < 32; ++c) {
-            float inv = std::pow(10000.0f, 2.0f * (c / 2) / 32.0f);
-            float v = ph / inv;
-            lr_pos[p * 32 + c] = (c % 2 == 0) ? std::sin(v) : std::cos(v);
-        }
-    }
-    for (int i = 0; i < P * 32; ++i) lr_text[i] += lr_pos[i];
-    int M = P / 3;
-    memory.assign(M * 160, 0.0f);
-    for (int m = 0; m < M; ++m) {
-        for (int c = 0; c < 96; ++c) memory[m * 160 + c] = lr_text[m * 96 + c];
-        for (int c = 0; c < 32; ++c) {
-            memory[m * 160 + 96 + c] = lr_spk[m * 96 + c];
-            memory[m * 160 + 128 + c] = lr_emo[m * 96 + c];
-        }
-    }
-    lr_len = sum;
-}
-
 // PNCA 单步解码（host）
 struct Decoder {
     struct LW {
@@ -692,28 +478,16 @@ struct Decoder {
 };
 
 
-std::vector<float> Postnet(const std::vector<float>& dec, const Weights& w, int T) {
-    std::vector<float> x = FsmnEncoder(dec, w, "post", T, 80, {17, 17, 17, 17});
-    std::vector<float> h(128, 0), c(128, 0), out(T * 128);
-    std::vector<float> xi(256);
-    for (int t = 0; t < T; ++t) {
-        std::copy(x.begin() + t * 256, x.begin() + (t + 1) * 256, xi.begin());
-        LstmCell(xi, w.Get("post_lstm_w_ih"), w.Get("post_lstm_w_hh"), w.Get("post_lstm_b_ih"),
-                 w.Get("post_lstm_b_hh"), h, c, 128);
-        std::copy(h.begin(), h.end(), out.begin() + t * 128);
-    }
-    std::vector<float> res(T * 80);
-    Matmul(out, w.Get("post_fc_w"), w.Get("post_fc_b"), T, 128, 80, res);
-    for (int i = 0; i < T * 80; ++i) res[i] += dec[i];
-    return res;
-}
-
 }  // namespace
 
 KanttsPipeline::KanttsPipeline(const std::string& model_dir, const std::string& resource_dir,
                                const std::string& am_config)
     : enc_(new ModelSession(model_dir + "/am_enc.axmodel")),
       voc_(new ModelSession(model_dir + "/voc.axmodel")),
+      pe_(new ModelSession(model_dir + "/pitch_energy.axmodel")),
+      dur_(new ModelSession(model_dir + "/duration.axmodel")),
+      post_(new ModelSession(model_dir + "/postnet.axmodel")),
+      model_dir_(model_dir),
       frontend_(new Frontend(resource_dir, am_config)) {
     w_.Load(model_dir + "/host_weights");
     std::fprintf(stderr, "[stage] weights loaded\n");
@@ -800,7 +574,98 @@ std::vector<float> KanttsPipeline::SynthesizeSymbols(
             }
             std::fprintf(stderr, "[dbg] 使用参考 memory（%d 行）\n", (int)memory.size() / 160);
         } else {
-            BuildMemory(text_hid, spk_hid, emo_hid, w_, T, memory, lr_len, durations);
+            // pitch/energy/duration 走 NPU
+            std::vector<float> var_in(T * 96);
+            for (int t = 0; t < T; ++t)
+                for (int c = 0; c < 32; ++c) {
+                    var_in[t * 96 + c] = text_hid[t * 32 + c];
+                    var_in[t * 96 + 32 + c] = spk_hid[t * 32 + c];
+                    var_in[t * 96 + 64 + c] = emo_hid[t * 32 + c];
+                }
+            std::vector<float> pitch(T), energy(T);
+            std::vector<float> var_pad(128 * 96, 0.0f);
+            std::copy(var_in.begin(), var_in.end(), var_pad.begin());
+            pe_->SetInput("var_in", var_pad.data(), var_pad.size() * 4);
+            pe_->Run();
+            pe_->GetOutput("pitch", pitch.data(), pitch.size() * 4);
+            pe_->GetOutput("energy", energy.data(), energy.size() * 4);
+            std::vector<float> pe_c, ee_c;
+            Conv1dSame(pitch, w_.Get("pitch_emb_w"), w_.Get("pitch_emb_b"), T, 1, 32, 9, pe_c);
+            Conv1dSame(energy, w_.Get("energy_emb_w"), w_.Get("energy_emb_b"), T, 1, 32, 9, ee_c);
+            std::vector<float> aug(T * 32);
+            for (int i = 0; i < T * 32; ++i) aug[i] = text_hid[i] + pe_c[i] + ee_c[i];
+            std::vector<float> cond(T * 96);
+            for (int t = 0; t < T; ++t)
+                for (int c = 0; c < 32; ++c) {
+                    cond[t * 96 + c] = aug[t * 32 + c];
+                    cond[t * 96 + 32 + c] = spk_hid[t * 32 + c];
+                    cond[t * 96 + 64 + c] = emo_hid[t * 32 + c];
+                }
+            std::vector<float> log_dur(T);
+            std::vector<float> cond_pad(22 * 96, 0.0f);
+            std::copy(cond.begin(), cond.end(), cond_pad.begin());
+            dur_->SetInput("cond", cond_pad.data(), cond_pad.size() * 4);
+            dur_->Run();
+            dur_->GetOutput("log_dur", log_dur.data(), log_dur.size() * 4);
+            if (std::getenv("KANTTS_DUMP_ENC")) {
+                std::fprintf(stderr, "[dbg-npu] pitch[0..3]=%.4f %.4f %.4f %.4f energy[0..3]=%.4f %.4f %.4f %.4f log_dur[0..3]=%.4f %.4f %.4f %.4f\n",
+                             pitch[0], pitch[1], pitch[2], pitch[3],
+                             energy[0], energy[1], energy[2], energy[3],
+                             log_dur[0], log_dur[1], log_dur[2], log_dur[3]);
+            }
+            durations.resize(T);
+            int sum = 0;
+            std::vector<int> reps(T);
+            for (int t = 0; t < T; ++t) {
+                durations[t] = std::exp(log_dur[t]) - 1.0f;
+                reps[t] = (int)(durations[t] + 0.5f);
+                sum += reps[t];
+            }
+            if (std::getenv("KANTTS_DUMP_ENC")) {
+                std::fprintf(stderr, "[dbg-npu] log_dur all:");
+                for (int t = 0; t < T; ++t) std::fprintf(stderr, " %.3f", log_dur[t]);
+                std::fprintf(stderr, " | reps sum=%d\n", sum);
+            }
+            int pad = 3 - sum % 3;
+            if (pad == 3) pad = 0;
+            int P = sum + pad;
+            auto expand = [&](const std::vector<float>& src, std::vector<float>& dst) {
+                dst.assign(P * 32, 0.0f);
+                int pos = 0;
+                for (int t = 0; t < T; ++t)
+                    for (int r = 0; r < reps[t]; ++r) {
+                        std::copy(src.begin() + t * 32, src.begin() + (t + 1) * 32,
+                                  dst.begin() + (pos++) * 32);
+                    }
+            };
+            std::vector<float> lr_text, lr_emo, lr_spk;
+            expand(aug, lr_text);
+            expand(emo_hid, lr_emo);
+            expand(spk_hid, lr_spk);
+            std::vector<float> rc(T + 1, 0);
+            for (int t = 0; t < T; ++t) rc[t + 1] = rc[t] + reps[t];
+            std::vector<float> lr_pos(P * 32, 0.0f);
+            for (int p = 0; p < P; ++p) {
+                int ph = 0;
+                for (int t = 0; t < T; ++t)
+                    if (rc[t] <= p && p < rc[t + 1]) { ph = p - rc[t] + 1; break; }
+                for (int c = 0; c < 32; ++c) {
+                    float inv = std::pow(10000.0f, 2.0f * (c / 2) / 32.0f);
+                    float v = ph / inv;
+                    lr_pos[p * 32 + c] = (c % 2 == 0) ? std::sin(v) : std::cos(v);
+                }
+            }
+            for (int i = 0; i < P * 32; ++i) lr_text[i] += lr_pos[i];
+            int MM = P / 3;
+            memory.assign(MM * 160, 0.0f);
+            for (int m = 0; m < MM; ++m) {
+                for (int c = 0; c < 96; ++c) memory[m * 160 + c] = lr_text[m * 96 + c];
+                for (int c = 0; c < 32; ++c) {
+                    memory[m * 160 + 96 + c] = lr_spk[m * 96 + c];
+                    memory[m * 160 + 128 + c] = lr_emo[m * 96 + c];
+                }
+            }
+            lr_len = sum;
         }
         int M = (int)memory.size() / 160;
         std::fprintf(stderr, "[stage] memory M=%d lr_len=%d\n", M, lr_len);
@@ -812,25 +677,92 @@ std::vector<float> KanttsPipeline::SynthesizeSymbols(
         }
         int x_band = (int)(*std::max_element(durations.begin(), durations.end()) / 3.0f + 0.5f);
         std::fprintf(stderr, "[stage] x_band=%d\n", x_band);
-        Decoder dec(w_);
-        dec.Prepare(memory);
-        std::fprintf(stderr, "[timing] host(预测+memory) %.0fms\n", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now()-t_stage).count());
-        t_stage = std::chrono::steady_clock::now();
-        std::vector<float> xk(12 * 8 * 270 * 16, 0.0f), xv(12 * 8 * 270 * 16, 0.0f);
-        std::vector<float> frame(80, 0.0f), out;
         std::vector<float> dec_all(M * 3 * 80);
         double dec_sum = 0;
-        for (int s = 0; s < M; ++s) {
-            std::vector<float> mem_step(memory.begin() + s * 160, memory.begin() + (s + 1) * 160);
-            dec.Step(frame, mem_step, xk, xv, s, x_band, out);
-            std::copy(out.begin(), out.begin() + 240, dec_all.begin() + s * 240);
-            std::copy(out.begin() + 160, out.begin() + 240, frame.begin());
+        std::fprintf(stderr, "[timing] host(预测+memory) %.0fms\n", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now()-t_stage).count());
+        t_stage = std::chrono::steady_clock::now();
+        // 交付配置：am_dec（PNCA 解码）默认 CPU，其余（enc/pe/dur/postnet/voc）全 NPU；
+        // KANTTS_NPU_DEC=1 可切回 NPU 解码（QAT 实验用）。
+        const bool dec_npu = std::getenv("KANTTS_NPU_DEC") != nullptr;
+        if (dec_npu) {
+            if (!dec_) dec_.reset(new ModelSession(model_dir_ + "/am_dec.axmodel"));
+            static const char* k_names[12] = {
+                "dequantize_per_tensor_101", "dequantize_per_tensor_166",
+                "dequantize_per_tensor_231", "dequantize_per_tensor_296",
+                "dequantize_per_tensor_361", "dequantize_per_tensor_426",
+                "dequantize_per_tensor_491", "dequantize_per_tensor_556",
+                "dequantize_per_tensor_621", "dequantize_per_tensor_686",
+                "dequantize_per_tensor_751", "dequantize_per_tensor_816"};
+            static const char* v_names[12] = {
+                "dequantize_per_tensor_103", "dequantize_per_tensor_168",
+                "dequantize_per_tensor_233", "dequantize_per_tensor_298",
+                "dequantize_per_tensor_363", "dequantize_per_tensor_428",
+                "dequantize_per_tensor_493", "dequantize_per_tensor_558",
+                "dequantize_per_tensor_623", "dequantize_per_tensor_688",
+                "dequantize_per_tensor_753", "dequantize_per_tensor_818"};
+            std::vector<float> mem_pad(270 * 160, 0.0f);
+            std::copy(memory.begin(), memory.end(), mem_pad.begin());
+            std::vector<float> xk(12 * 8 * 270 * 16, 0.0f), xv(12 * 8 * 270 * 16, 0.0f);
+            std::vector<float> frame(80, 0.0f), out(240), kbuf(8 * 16), vbuf(8 * 16);
+            int32_t xb = x_band, ml = M;
+            for (int s = 0; s < M; ++s) {
+                dec_->SetInput("mel_frame", frame.data(), frame.size() * 4);
+                dec_->SetInput("memory_step", memory.data() + s * 160, 160 * 4);
+                dec_->SetInput("memory", mem_pad.data(), mem_pad.size() * 4);
+                dec_->SetInput("x_k", xk.data(), xk.size() * 4);
+                dec_->SetInput("x_v", xv.data(), xv.size() * 4);
+                int32_t step_v = s;
+                dec_->SetInput("step", &step_v, 4);
+                dec_->SetInput("x_band", &xb, 4);
+                dec_->SetInput("h_band", &xb, 4);
+                dec_->SetInput("mem_len", &ml, 4);
+                dec_->Run();
+                dec_->GetOutput("output", out.data(), out.size() * 4);
+                std::copy(out.begin(), out.begin() + 240, dec_all.begin() + s * 240);
+                std::copy(out.begin() + 160, out.begin() + 240, frame.begin());
+                for (int li = 0; li < 12; ++li) {
+                    dec_->GetOutput(k_names[li], kbuf.data(), kbuf.size() * 4);
+                    dec_->GetOutput(v_names[li], vbuf.data(), vbuf.size() * 4);
+                    for (int h = 0; h < 8; ++h)
+                        for (int d = 0; d < 16; ++d) {
+                            xk[(li * 8 + h) * 270 * 16 + s * 16 + d] = kbuf[h * 16 + d];
+                            xv[(li * 8 + h) * 270 * 16 + s * 16 + d] = vbuf[h * 16 + d];
+                        }
+                }
+            }
+            std::fprintf(stderr, "[dbg] dec NPU %d 步\n", M);
+        } else {
+            Decoder dec(w_);
+            dec.Prepare(memory);
+            std::vector<float> xk(12 * 8 * 270 * 16, 0.0f), xv(12 * 8 * 270 * 16, 0.0f);
+            std::vector<float> frame(80, 0.0f), out;
+            for (int s = 0; s < M; ++s) {
+                std::vector<float> mem_step(memory.begin() + s * 160, memory.begin() + (s + 1) * 160);
+                dec.Step(frame, mem_step, xk, xv, s, x_band, out);
+                std::copy(out.begin(), out.begin() + 240, dec_all.begin() + s * 240);
+                std::copy(out.begin() + 160, out.begin() + 240, frame.begin());
+            }
         }
         for (size_t i = 0; i < dec_all.size(); ++i) dec_sum += dec_all[i] * dec_all[i];
         std::fprintf(stderr, "[dbg] dec rms=%.4f\n", std::sqrt(dec_sum / dec_all.size()));
         std::fprintf(stderr, "[timing] decode %d 步 %.0fms\n", M, std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now()-t_stage).count());
         t_stage = std::chrono::steady_clock::now();
-        std::vector<float> mel = Postnet(dec_all, w_, M * 3);
+        std::vector<float> mel;
+        {
+            // postnet 模型固定 128 帧输入；M*3 可能超过 128，按 128 帧分块处理
+            const int Tf = M * 3;
+            for (int start = 0; start < Tf; start += 128) {
+                int n = std::min(128, Tf - start);
+                std::vector<float> dec_p(128 * 80, 0.0f);
+                std::copy(dec_all.begin() + start * 80, dec_all.begin() + (start + n) * 80,
+                          dec_p.begin());
+                post_->SetInput("dec", dec_p.data(), dec_p.size() * 4);
+                post_->Run();
+                std::vector<float> mel_p(128 * 80);
+                post_->GetOutput("output", mel_p.data(), mel_p.size() * 4);
+                mel.insert(mel.end(), mel_p.begin(), mel_p.begin() + n * 80);
+            }
+        }
         std::fprintf(stderr, "[timing] postnet %.0fms\n", std::chrono::duration<double, std::milli>(std::chrono::steady_clock::now()-t_stage).count());
         t_stage = std::chrono::steady_clock::now();
         double mel_sum = 0;