Upload folder using huggingface_hub

README.md

@@ -77,6 +77,8 @@ OPENAI_BASE_URL=http://127.0.0.1:8001/v1  # 本地 OpenAI 协议服务时设置
 OPENAI_MODEL=AXERA-TECH/Qwen3-1.7B
 HOST=0.0.0.0
 PORT=8000
+SSL_CERT=cert.pem
+SSL_KEY=key.pem
 ```
 
 依赖提示（WebSocket）：
@@ -85,6 +87,18 @@ PORT=8000
 设备权限提示：
 - 如果遇到 `/dev/axcl_host` 权限错误，请用有权限的账号或 `sudo` 运行
 
+HTTPS（推荐，便于浏览器麦克风权限）：
+
+```bash
+openssl req -x509 -newkey rsa:2048 -nodes \\
+  -keyout key.pem -out cert.pem -days 365 \\
+  -subj "/CN=<你的IP>"
+```
+
+```bash
+SSL_CERT=cert.pem SSL_KEY=key.pem python -m app.server
+```
+
 ![meeting_demo.png](assert/meeting_demo.png)
 
 

app/cli_batch.py

@@ -9,7 +9,8 @@ import soundfile as sf
 from app.model_bundle import ModelBundle
 from app.summarizer import IncrementalSummarizer
 from utils.vad_utils import merge_vad
-from utils.ax_cam_bin import do_clustering, distribute_spk, get_trans_sentence_sensevoice, chunk
+from utils.ax_cam_bin import do_clustering, chunk
+from app.diar_utils import pick_speaker
 from app.config import MERGE_VAD_MAX_LEN_MS
 
 
@@ -46,47 +47,24 @@ def diar_asr(bundle: ModelBundle, speech: np.ndarray, fs: int = 16000) -> str:
     embeddings = bundle.speaker_infer(speech, fs, chunks=chunks)
     _, diar_results = do_clustering(chunks, embeddings, speaker_num=None)
 
-    audio_duration = speech.shape[0] / fs
-    all_metadata = {}
-
+    lines = []
     for i, segment in enumerate(vad_segments):
         segment_start, segment_end = segment
         start_sample = int(segment_start / 1000 * fs)
         end_sample = min(int(segment_end / 1000 * fs), speech.shape[0])
         segment_speech = speech[start_sample:end_sample]
-        time_offset_sec = segment_start / 1000.0
 
-        _, segment_meta = bundle.asr_infer(
+        text, _ = bundle.asr_infer(
             segment_speech,
-            output_timestamp=True,
+            output_timestamp=False,
             key=f"segment_{i}",
         )
+        if not text or not text.strip():
+            continue
 
-        if "merged_words" in segment_meta:
-            all_metadata.setdefault("merged_words", []).extend(segment_meta["merged_words"])
-
-        if "merged_timestamps" in segment_meta:
-            adjusted = [
-                [
-                    min(ts[0] + time_offset_sec, audio_duration),
-                    min(ts[1] + time_offset_sec, audio_duration),
-                ]
-                for ts in segment_meta["merged_timestamps"]
-            ]
-            all_metadata.setdefault("merged_timestamps", []).extend(adjusted)
-
-    output_asr = {
-        "merged_words": all_metadata.get("merged_words", []),
-        "merged_timestamps": all_metadata.get("merged_timestamps", []),
-    }
-
-    asr_timestamps = get_trans_sentence_sensevoice(output_asr)
-    sentence_info_with_spk = distribute_spk(asr_timestamps, diar_results)
-
-    lines = []
-    for text_string, timeinterval, spk in sentence_info_with_spk:
+        spk = pick_speaker(segment_start / 1000.0, segment_end / 1000.0, diar_results)
         lines.append(
-            f"Speaker_{spk}: [{timeinterval[0]:.3f} {timeinterval[1]:.3f}] {text_string}"
+            f"Speaker_{spk}: [{segment_start/1000.0:.3f} {segment_end/1000.0:.3f}] {text.strip()}"
         )
     return "\n".join(lines)
 

app/diar_utils.py

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+
+def pick_speaker(seg_st: float, seg_ed: float, diar_results) -> int:
+    if not diar_results:
+        return 0
+    best_spk = diar_results[0][2]
+    best_overlap = 0.0
+    for st_spk, ed_spk, spk in diar_results:
+        overlap = min(seg_ed, ed_spk) - max(seg_st, st_spk)
+        if overlap > best_overlap:
+            best_overlap = overlap
+            best_spk = spk
+    return int(best_spk)

app/model_bundle.py

@@ -8,7 +8,7 @@ from utils.ax_model_bin import AX_SenseVoiceSmall
 from utils.ax_vad_bin import AX_Fsmn_vad
 from utils.ax_cam_bin import AX_SpeakerEmbeddingInference
 from utils.sentencepiece_tokenizer import SentencepiecesTokenizer
-import re
+from app.text_cleaner import clean_asr_text
 
 
 class ModelBundle:
@@ -76,39 +76,5 @@ class ModelBundle:
                 key=[key],
             )
         text = "".join([r.get("text", "") for r in results])
-        text = self._clean_asr_text(text)
+        text = clean_asr_text(text)
         return text, meta
-
-    @staticmethod
-    def _clean_asr_text(text: str) -> str:
-        if not text:
-            return ""
-        # Remove token tags like <|zh|>, <|SPEECH|> or broken sequences
-        text = re.sub(r"<\\|[^>]*?\\|>", "", text)
-        text = re.sub(r"<\\|[^|>]*\\|", "", text)
-        text = text.replace("<|", "").replace("|>", "")
-        # Remove plain token chains like zh|NEUTRAL|Speech|withitn|
-        text = re.sub(
-            r"(?:\\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\\b\\|)+",
-            "",
-            text,
-            flags=re.IGNORECASE,
-        )
-        # Remove leftover meta tokens joined by pipes anywhere
-        text = re.sub(
-            r"\\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\\b",
-            "",
-            text,
-            flags=re.IGNORECASE,
-        )
-        text = text.replace("|", "")
-        # Remove standalone metadata tokens (case-insensitive)
-        meta_re = r"\\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\\b"
-        text = re.sub(meta_re, "", text, flags=re.IGNORECASE)
-        # Remove concatenated metadata tokens like zhEMO_UNKNOWNSpeechwithitn
-        meta_tokens = ["zh","en","yue","ja","ko","speech","happy","sad","angry","neutral","emo_unknown","withitn","woitn"]
-        meta_concat_re = r"(?:%s)+" % "|".join(meta_tokens)
-        text = re.sub(meta_concat_re, "", text, flags=re.IGNORECASE)
-        # Normalize spaces
-        text = re.sub(r"\\s+", " ", text).strip()
-        return text

app/pipeline.py

@@ -14,12 +14,8 @@ from app.config import (
     MERGE_VAD_MAX_LEN_MS,
 )
 from utils.vad_utils import merge_vad
-from utils.ax_cam_bin import (
-    do_clustering,
-    distribute_spk,
-    get_trans_sentence_sensevoice,
-    chunk,
-)
+from utils.ax_cam_bin import do_clustering, chunk
+from app.diar_utils import pick_speaker
 
 
 @dataclass
@@ -145,48 +141,23 @@ class StreamingMeetingSession:
         embeddings = self.model_bundle.speaker_infer(speech, self.sample_rate, chunks=chunks)
         _, diar_results = do_clustering(chunks, embeddings, speaker_num=None)
 
-        audio_duration = speech.shape[0] / self.sample_rate
-        all_metadata: Dict[str, List] = {}
-
+        lines = []
         for i, segment in enumerate(vad_segments):
             segment_start, segment_end = segment
             start_sample = int(segment_start / 1000 * self.sample_rate)
             end_sample = min(int(segment_end / 1000 * self.sample_rate), speech.shape[0])
             segment_speech = speech[start_sample:end_sample]
-            time_offset_sec = segment_start / 1000.0
 
-            _, segment_meta = self.model_bundle.asr_infer(
+            text, _ = self.model_bundle.asr_infer(
                 segment_speech,
-                output_timestamp=True,
+                output_timestamp=False,
                 key=f"segment_{i}",
             )
-
-            if "merged_words" in segment_meta:
-                all_metadata.setdefault("merged_words", []).extend(segment_meta["merged_words"])
-
-            if "merged_timestamps" in segment_meta:
-                adjusted = [
-                    [
-                        min(ts[0] + time_offset_sec, audio_duration),
-                        min(ts[1] + time_offset_sec, audio_duration),
-                    ]
-                    for ts in segment_meta["merged_timestamps"]
-                ]
-                all_metadata.setdefault("merged_timestamps", []).extend(adjusted)
-
-        output_asr = {
-            "merged_words": all_metadata.get("merged_words", []),
-            "merged_timestamps": all_metadata.get("merged_timestamps", []),
-        }
-
-        asr_timestamps = get_trans_sentence_sensevoice(output_asr)
-        sentence_info_with_spk = distribute_spk(asr_timestamps, diar_results)
-
-        lines = []
-        for text_string, timeinterval, spk in sentence_info_with_spk:
-            if not text_string or not text_string.strip():
+            if not text or not text.strip():
                 continue
+
+            spk = pick_speaker(segment_start / 1000.0, segment_end / 1000.0, diar_results)
             lines.append(
-                f"Speaker_{spk}: [{timeinterval[0]:.3f} {timeinterval[1]:.3f}] {text_string}"
+                f"Speaker_{spk}: [{segment_start/1000.0:.3f} {segment_end/1000.0:.3f}] {text.strip()}"
             )
         return "\n".join(lines)

app/server.py

@@ -85,6 +85,8 @@ if __name__ == "__main__":
 
     host = os.getenv("HOST", "0.0.0.0")
     port = int(os.getenv("PORT", "8000"))
+    ssl_cert = os.getenv("SSL_CERT")
+    ssl_key = os.getenv("SSL_KEY")
     try:
         s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
         s.connect(("8.8.8.8", 80))
@@ -92,5 +94,13 @@ if __name__ == "__main__":
         s.close()
     except Exception:
         local_ip = "127.0.0.1"
-    print(f"Local URL:  http://{local_ip}:{port}")
-    uvicorn.run("app.server:app", host=host, port=port, reload=False)
+    scheme = "https" if ssl_cert and ssl_key else "http"
+    print(f"Local URL:  {scheme}://{local_ip}:{port}")
+    uvicorn.run(
+        "app.server:app",
+        host=host,
+        port=port,
+        reload=False,
+        ssl_certfile=ssl_cert,
+        ssl_keyfile=ssl_key,
+    )

app/static/app.js

@@ -66,6 +66,11 @@ async function startMeeting() {
   finalTranscript.textContent = '';
   liveLog.innerHTML = '';
 
+  if (!window.isSecureContext && location.hostname !== 'localhost' && location.hostname !== '127.0.0.1') {
+    logLine('麦克风权限需要 HTTPS 或 localhost 访问。');
+    alert('麦克风权限需要 HTTPS 或 localhost 访问。请使用 https 或在本机用 127.0.0.1 访问。');
+  }
+
   const wsProtocol = location.protocol === 'https:' ? 'wss' : 'ws';
   ws = new WebSocket(`${wsProtocol}://${location.host}/ws`);
   ws.binaryType = 'arraybuffer';
@@ -87,7 +92,13 @@ async function startMeeting() {
   };
 
   ws.onopen = async () => {
-    mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    try {
+      mediaStream = await navigator.mediaDevices.getUserMedia({ audio: true });
+    } catch (err) {
+      logLine(`麦克风权限请求失败: ${err && err.name ? err.name : err}`);
+      alert('麦克风权限请求失败。请检查浏览器权限或使用 HTTPS/localhost。');
+      return;
+    }
     audioCtx = new (window.AudioContext || window.webkitAudioContext)();
     sourceNode = audioCtx.createMediaStreamSource(mediaStream);
 

app/text_cleaner.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+import re
+
+
+def clean_asr_text(text: str) -> str:
+    if not text:
+        return ""
+    # Remove token tags like <|zh|>, <|SPEECH|> or broken sequences
+    text = re.sub(r"<\|[^>]*?\|>", "", text)
+    text = re.sub(r"<\|[^|>]*\|", "", text)
+    text = text.replace("<|", "").replace("|>", "")
+
+    # Remove plain token chains like zh|NEUTRAL|Speech|withitn|
+    text = re.sub(
+        r"(?:\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\b\|)+",
+        "",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    # Remove leftover meta tokens joined by pipes anywhere
+    text = re.sub(
+        r"\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\b",
+        "",
+        text,
+        flags=re.IGNORECASE,
+    )
+    text = text.replace("|", "")
+
+    # Remove standalone metadata tokens (case-insensitive)
+    meta_re = r"\b(zh|en|yue|ja|ko|speech|happy|sad|angry|neutral|emo_unknown|withitn|woitn)\b"
+    text = re.sub(meta_re, "", text, flags=re.IGNORECASE)
+
+    # Remove concatenated metadata tokens like zhEMO_UNKNOWNSpeechwithitn
+    meta_tokens = ["zh","en","yue","ja","ko","speech","happy","sad","angry","neutral","emo_unknown","withitn","woitn"]
+    meta_concat_re = r"(?:%s)+" % "|".join(meta_tokens)
+    text = re.sub(meta_concat_re, "", text, flags=re.IGNORECASE)
+
+    # Normalize spaces
+    text = re.sub(r"\s+", " ", text).strip()
+    return text

cert.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDETCCAfmgAwIBAgIUPI3rAC24IoJ7FUydYijEOp7GeygwDQYJKoZIhvcNAQEL
+BQAwGDEWMBQGA1UEAwwNMTAuMTI2LjMzLjE0MDAeFw0yNjAyMjcwMzE3MzRaFw0y
+NzAyMjcwMzE3MzRaMBgxFjAUBgNVBAMMDTEwLjEyNi4zMy4xNDAwggEiMA0GCSqG
+SIb3DQEBAQUAA4IBDwAwggEKAoIBAQChzhKivPsGUSjfzFWwocMg1FT56iDFo8yy
+tba/LvbP2i2BpujTqK5/6iInLh6N9ZptJg4PsLSEQ2HWfLdYupEYvMrXDy4nYwsX
+gAbrjAz3uhsJV2+LSVF/0g8PNhwidDN4WNWLQoVf5g9FCxl0SneCoyKpQdpIB10r
+J0ZXtKe5SY9Ydq0EdjS+5898U83XgOIFQfKDRdakPuxKLX00DFd6S5Xz4Yw148As
+ypAOfNSXCqX0+2wtSyfAednwlPea+VxQPExQBpx7yOYe0eDrMDDPP7z6UUdzMdoD
+ZOlWTgtIarBCthD9HnhZhqK6iom9sxm9hvHOV+kM/pje1iMeaFbpAgMBAAGjUzBR
+MB0GA1UdDgQWBBRhENjhWth7MneI5GxGFzCu2RjUbTAfBgNVHSMEGDAWgBRhENjh
+Wth7MneI5GxGFzCu2RjUbTAPBgNVHRMBAf8EBTADAQH/MA0GCSqGSIb3DQEBCwUA
+A4IBAQAXi8HfQF1LyACZSkilE6emnB0zh31NMR7oimhc9rlKgX5yPD4RQp+OKr8l
+APeIFeWLiHadvxKpjnT+MQwzODs5i+Qai0vDaRoy/OLPiaI3rH8yaAMxMI0hrh4c
+Rfyf6bWBvcTpuUTFO/hC1KxfVVCjCwMcV/Jmv0xukCMCXCHNqDdkG2m24RSmKUHl
+Af85bduX8PabtZxEDESkLc2Z8G8w5VvEWJizQ7OF0EcYJIA3JEDcr50o5kFpu7OQ
+ZkRfWopQ3I1DOUOfSrc4d5gMy3b1rvDBbeLTRsNnec9WciwP4U/+Hbxs2P+BALo+
+WSq6D7FC0WTTXtYdGFv2oY5s38Dr
+-----END CERTIFICATE-----

key.pem

@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQChzhKivPsGUSjf
+zFWwocMg1FT56iDFo8yytba/LvbP2i2BpujTqK5/6iInLh6N9ZptJg4PsLSEQ2HW
+fLdYupEYvMrXDy4nYwsXgAbrjAz3uhsJV2+LSVF/0g8PNhwidDN4WNWLQoVf5g9F
+Cxl0SneCoyKpQdpIB10rJ0ZXtKe5SY9Ydq0EdjS+5898U83XgOIFQfKDRdakPuxK
+LX00DFd6S5Xz4Yw148AsypAOfNSXCqX0+2wtSyfAednwlPea+VxQPExQBpx7yOYe
+0eDrMDDPP7z6UUdzMdoDZOlWTgtIarBCthD9HnhZhqK6iom9sxm9hvHOV+kM/pje
+1iMeaFbpAgMBAAECggEAQjovPYX9dy3z/XpM3pGvZPoT2AEBLfQn/kPLS4CFDDlg
+o+814CBsYDXsib3iSreq4B8R5VEt6e8MljaQ8xPV/NqVaaYwfXWYHiPMcU/vJNx7
+YXz0zn2RirBncpHyvRVz1cACk9AD+GcZe+iZoBQ0y3dLYhzuo8nD1Dxsmcx7VCaF
+VTAVKGsCSW3ZHfXXxMDkB/3tiRknb4KNpvVzLo2GNgj5fiygkkgf9hM1hRfqt7/P
+nejF3A0laWQc0N0OluM6SF+2A4uNnWQwIeyLK/AdM14Me5rvYjiOG/xE1hNVBvup
+utkjVyVYP1pCoK0eCqaApd61DuDcagFPi6gSmKeY4wKBgQDXF0cGE6tbohNUa/GU
+r8jCb51F1gWuLJNl4y6SMDr9/iku1OKkJtbK0InMmfeyeKeg/xeuXSc5QJY5hcrd
+A/Y4mTRWlpfzpYCj5qos7f1HVl/mtwBqN2VUVi2Tid1OrfDgTup0ZZlN1IjszH3/
+37IQnJTs/sfVxwwh+ij+VKvP6wKBgQDAlFDTq8lRtbc/nVAqLPnnc2HnLtrAzeLg
+N1qD7QQvcfWP9gxSg0ZBYJf52uYRjLDB4b6LBPV5Ys9SIcXz8G6VYwUESkJcnQ+s
+yTNUuJolzAFq0NoMLAAN0vKV2yyIdGP/oupTYEfSRz1bRtIGchhY/XMdVjj5Ppxc
+w3CfAAcTewKBgCI4nuE1oe7bU437+py4dw2Qaopg6dhzWSQ9x/wUVl5w4KaF0mVh
+lI0CLtpxqLopfiocS+0+/u2Z/Ay837DYX4VTwsMABL8MFvJ80ZiCaOi/slRny1Ya
+6DFJ4Mh3h9Fr1UYq6ByKyaBbb0mVo3phYdhIwV0PkEXP/HsvbPRCDm/vAoGBALng
+bgNgk/giBLWKCY4ryyny3FRfjRT7pDf2NY+QfbGttO829b3Op0kDCq1G8zmNKi54
+zYkxSB3ZmXIU1xQUxSe7Y2Q4qMTrc+26ZakoZOCGf/exjkShU4wER9EMs3choENl
+4/aFv8zepgIr4RwHlCiQuUNfra4lGJcQrOtLA4lxAoGAWn8ovOGTEo5Seuq5CoCQ
+HbDdMmd6z9kLInKcqaGsuclFaEZjG6CHznD7B+SRtJFBN3+L0K3UbwNeAka6yEqg
+3TUXNBXMypOKYPYDAbGE8t7wrLL7WEtgHiqpkN/zZoxX61f3nLOIoku817dW3KtW
+PTUCWpm7u5IQWl6T+ThOJmU=
+-----END PRIVATE KEY-----

requirements.txt

@@ -1,7 +1,5 @@
-torch
-tqdm
-funasr==1.2.7
-torchaudio
+numpy
+soundfile
 kaldi_native_fbank
 fastcluster
 hdbscan
@@ -10,5 +8,5 @@ loguru
 gradio
 fastapi
 uvicorn
-soundfile
+websockets
 openai

tests/test_lightweight.py

@@ -0,0 +1,42 @@
+# -*- coding: utf-8 -*-
+import unittest
+
+from app.text_cleaner import clean_asr_text
+from app.diar_utils import pick_speaker
+
+
+class TestTextCleaner(unittest.TestCase):
+    def test_angle_tokens(self):
+        s = "<|zh|<|NEUTRAL|<|Speech|<|withitn|嗯，你好你好你好。"
+        self.assertEqual(clean_asr_text(s), "嗯，你好你好你好。")
+
+    def test_pipe_tokens(self):
+        s = "zh|NEUTRAL|Speech|withitn|他相当于把一个平台就把一个拼行能力拆分掉了。"
+        self.assertEqual(clean_asr_text(s), "他相当于把一个平台就把一个拼行能力拆分掉了。")
+
+    def test_concat_tokens(self):
+        s = "zhEMO_UNKNOWNSpeechwithitn房止追后了对这种方式掉。"
+        self.assertEqual(clean_asr_text(s), "房止追后了对这种方式掉。")
+
+    def test_empty_after_clean(self):
+        s = "zh|NEUTRAL|Speech|withitn|"
+        self.assertEqual(clean_asr_text(s), "")
+
+
+class TestPickSpeaker(unittest.TestCase):
+    def test_pick_speaker_overlap(self):
+        diar = [
+            [0.0, 2.0, 0],
+            [2.0, 5.0, 1],
+        ]
+        spk = pick_speaker(1.5, 3.5, diar)
+        self.assertEqual(spk, 1)
+
+    def test_pick_speaker_no_overlap(self):
+        diar = [[0.0, 1.0, 0]]
+        spk = pick_speaker(2.0, 3.0, diar)
+        self.assertEqual(spk, 0)
+
+
+if __name__ == "__main__":
+    unittest.main()

utils/ax_model_bin.py

@@ -6,12 +6,7 @@
 import os.path
 from pathlib import Path
 from typing import List, Union, Tuple
-try:
-    import torch
-    TORCH_AVAILABLE = True
-except Exception:
-    torch = None
-    TORCH_AVAILABLE = False
+TORCH_AVAILABLE = False
 import numpy as np
 import axengine as axe
 
@@ -34,7 +29,6 @@ from utils.infer_utils import (
     read_yaml,
 )
 from utils.frontend import WavFrontend
-from utils.ctc_alignment import ctc_forced_align
 
 logging = get_logger()
 
@@ -222,95 +216,10 @@ class AX_SenseVoiceSmall:
                     if ibest_writer is not None:
                         ibest_writer["text"][key[j]] = text
                     
-                    if output_timestamp and tokenizer is not None:
-                        if not TORCH_AVAILABLE:
-                            # Torch is required for CTC forced align. Skip timestamps in torch-free mode.
-                            output_timestamp = False
-                            result_i = {"key": key[j] if j < len(key) else f"result_{j}", "text": text}
-                            results.append(result_i)
-                            continue
-                        # Process timestamps similar to model.py
-                        from itertools import groupby
-                        timestamp = []
-                        tokens = tokenizer.text2tokens(text)[4:] if hasattr(tokenizer, 'text2tokens') else []
-                        # If ctc_forced_align is available, calculate timestamps
-                        if 'ctc_forced_align' in globals() or 'ctc_forced_align' in locals():
-                            softmax = torch.nn.Softmax(dim=-1)
-                            torch_ctc = torch.from_numpy(ctc_logits).float()
-                            enc_len_item = encoder_out_lens[j].item() if hasattr(encoder_out_lens[j], "item") else int(encoder_out_lens[j])
-                            logits_speech = softmax(torch_ctc[j, 4:enc_len_item, :])
-                            
-                            pred = logits_speech.argmax(-1).cpu()
-                            logits_speech[pred == self.blank_id, self.blank_id] = 0
-                            
-                            try:
-                    
-                                # Convert numpy types to PyTorch tensors where needed
-                                # Make sure encoder_out_lens is a torch.Tensor before calling .long()
-                                tokens_tensor = torch.Tensor(token_int[4:]).unsqueeze(0).long()
-                                
-                                # Handle numpy int64 by converting to torch tensor first
-                                if isinstance(encoder_out_lens[j], (np.integer, np.int64)):
-                                    lens_tensor = torch.tensor(int(encoder_out_lens[j]-4))
-                                else:
-                                    lens_tensor = (encoder_out_lens[j]-4)
-                                    if hasattr(lens_tensor, 'long'):
-                                        lens_tensor = lens_tensor.long()
-                                        
-                                token_len = torch.tensor(len(token_int)-4).unsqueeze(0)
-                                #token_len = torch.tensor(len(token_int)).unsqueeze(0)
-                                
-                                if hasattr(token_len, 'long'):
-                                    token_len = token_len.long()
-                                    
-                                align = ctc_forced_align(
-                                    logits_speech.unsqueeze(0).float(),
-                                    tokens_tensor,
-                                    lens_tensor,
-                                    token_len,
-                                    ignore_id=0
-                                )
-                                # 时间戳处理完成
-                                # Process alignment
-                                # Handle potential numpy type for slicing
-                                if isinstance(encoder_out_lens[j], (np.integer, np.int64)):
-                                    end_idx = int(encoder_out_lens[j]-4)
-                                else:
-                                    end_idx = encoder_out_lens[j]-4
-                                    if hasattr(end_idx, 'item'):
-                                        end_idx = end_idx.item()
-                                
-                                pred = groupby(align[0, :end_idx])
-                                _start = 0
-                                token_id = 0
-                                # Convert ts_max to the right type for calculation
-                                if isinstance(encoder_out_lens[j], (np.integer, np.int64)):
-                                    ts_max = int(encoder_out_lens[j] - 4)
-                                else:
-                                    ts_max = encoder_out_lens[j] - 4
-                                    if hasattr(ts_max, 'item'):
-                                        ts_max = ts_max.item()
-                                #timestamps_one_sentence = [] # Store timestamps for the current sentence
-                                for pred_token, pred_frame in pred:
-                                    _end = _start + len(list(pred_frame))
-                                    if pred_token != 0 and token_id < len(tokens):
-                                        # 计算时间戳，加上时间偏移以保持连续，精确保留两位小数
-                                        ts_left = round(max((_start*60-30)/1000, 0) + time_offset, 2)
-                                        ts_right = round(min((_end*60-30)/1000, (ts_max*60-30)/1000) + time_offset, 2)
-
-                                        merged_timestamps.append([ts_left, ts_right])
-                                        merged_words.append(tokens[token_id])
-                                        #timestamps_one_sentence.append(ts_entry)
-                                        token_id += 1
-                                    _start = _end
-                                #merged_timestamps.append(timestamps_one_sentence)
-                                # 时间戳处理完成
-                            except (ImportError, Exception) as e:
-                                logging.warning(f"Timestamp calculation failed: {e}")
-                        
-                        result_i = {"key": key[j] if j < len(key) else f"result_{j}", "text": text, "timestamp": timestamp}
-                    else:
-                        result_i = {"key": key[j] if j < len(key) else f"result_{j}", "text": text}
+                    if output_timestamp:
+                        # Torch-free build: skip timestamp generation
+                        output_timestamp = False
+                    result_i = {"key": key[j] if j < len(key) else f"result_{j}", "text": text}
                     
                     # 直接添加结果，重复处理将在export.py中进行
                     results.append(result_i)

utils/vad_utils.py

@@ -1,5 +1,4 @@
-import torch
-from torch.nn.utils.rnn import pad_sequence
+import numpy as np
 
 
 def slice_padding_fbank(speech, speech_lengths, vad_segments):
@@ -13,16 +12,21 @@ def slice_padding_fbank(speech, speech_lengths, vad_segments):
         speech_lengths_i = end_idx - bed_idx
         speech_list.append(speech_i)
         speech_lengths_list.append(speech_lengths_i)
-    feats_pad = pad_sequence(speech_list, batch_first=True, padding_value=0.0)
-    speech_lengths_pad = torch.Tensor(speech_lengths_list).int()
+    max_len = max(speech_lengths_list) if speech_lengths_list else 0
+    feats_pad = []
+    for arr in speech_list:
+        pad_len = max_len - arr.shape[0]
+        if pad_len > 0:
+            arr = np.pad(arr, (0, pad_len), mode="constant")
+        feats_pad.append(arr)
+    feats_pad = np.stack(feats_pad, axis=0) if feats_pad else np.zeros((0, 0), dtype=np.float32)
+    speech_lengths_pad = np.array(speech_lengths_list, dtype=np.int32)
     return feats_pad, speech_lengths_pad
 
 
 def slice_padding_audio_samples(speech, speech_lengths, vad_segments):
     speech_list = []
     speech_lengths_list = []
-    import pdb
-    pdb.set_trace()
     for i, segment in enumerate(vad_segments):
         bed_idx = int(segment[0][0] * 16)
         end_idx = min(int(segment[0][1] * 16), speech_lengths)
@@ -58,4 +62,4 @@ def merge_vad(vad_result, max_length=15000, min_length=0):
         #         new_result.append([bg + j * spl_l, bg + (j + 1) * spl_l])
         bg = time
     new_result.append([bg, time_step[-1]])
-    return new_result
+    return new_result