优化asr

examples/combined_podcast_transcription.py

@@ -20,10 +20,9 @@ def main():
     # audio_file = Path("/Users/konie/Desktop/voices/lex_ai_john_carmack_30.wav")
     
     # 模型配置
-    asr_model_name = "mlx-community/parakeet-tdt-0.6b-v2"  # ASR模型名称
+    asr_model_name = "mlx-community/"  # ASR模型名称
     diarization_model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
     llm_model_path = "mlx-community/gemma-3-12b-it-4bit-DWQ"
-    hf_token = ""  # Hugging Face API 令牌
     device = "mps"  # 设备类型
     segmentation_batch_size = 64
     parallel = True
@@ -33,12 +32,6 @@ def main():
         print(f"错误：文件 '{audio_file}' 不存在")
         return 1
     
-    # 检查HF令牌
-    if not hf_token:
-        print("警告：未设置HF_TOKEN环境变量，必须设置此环境变量才能使用pyannote说话人分离模型")
-        print("请执行：export HF_TOKEN='你的HuggingFace令牌'")
-        return 1
-    
     try:
         print(f"正在加载音频文件: {audio_file}")
         # 加载音频文件
@@ -67,7 +60,6 @@ def main():
     result = transcribe_podcast_audio(audio,
                              podcast_info=mock_podcast_info,
                              episode_info=mock_episode_info,
-                             hf_token=hf_token,
                              asr_model_name=asr_model_name,
                              diarization_model_name=diarization_model_name,
                              llm_model_name=llm_model_path,

examples/combined_transcription.py

@@ -27,7 +27,6 @@ def main():
     # 模型配置
     asr_model_name = "distil-whisper/distil-large-v3.5"  # ASR模型名称
     diarization_model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
-    hf_token = ""  # Hugging Face API 令牌
     device = "mps"  # 设备类型
     segmentation_batch_size = 64
     parallel = True
@@ -37,12 +36,6 @@ def main():
         print(f"错误：文件 '{audio_file}' 不存在")
         return 1
     
-    # 检查HF令牌
-    if not hf_token:
-        print("警告：未设置HF_TOKEN环境变量，必须设置此环境变量才能使用pyannote说话人分离模型")
-        print("请执行：export HF_TOKEN='你的HuggingFace令牌'")
-        return 1
-    
     try:
         print(f"正在加载音频文件: {audio_file}")
         # 加载音频文件
@@ -54,7 +47,6 @@ def main():
             audio, 
             asr_model_name=asr_model_name,
             diarization_model_name=diarization_model_name,
-            hf_token=hf_token,
             device=device,
             segmentation_batch_size=segmentation_batch_size,
             parallel=parallel,

examples/simple_asr.py

@@ -14,41 +14,26 @@ from pathlib import Path
 sys.path.insert(0, str(Path(__file__).parent.parent))
 
 from src.podcast_transcribe.audio import load_audio
+from src.podcast_transcribe.asr.asr_distil_whisper import transcribe_audio
 
 logger = logging.getLogger("asr_example")
 
 
 def main():
     """主函数"""
-    # audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
+    audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
     # audio_file = "/Users/konie/Desktop/voices/lex_ai_john_carmack_30.wav"  # 播客音频文件路径
-    audio_file = "/Users/konie/Desktop/voices/podcast1_1.wav"
+    # audio_file = "/Users/konie/Desktop/voices/podcast1_1.wav"
     # model = "distil-whisper"
-    model = "distil-whisper-transformers"
+    model = "distil-whisper/distil-large-v3.5"
 
-    device = "mlx"
+    device = "mps"
     
     # 检查文件是否存在
     if not os.path.exists(audio_file):
         print(f"错误：文件 '{audio_file}' 不存在")
         return 1
     
-    if model == "parakeet":
-        from src.podcast_transcribe.asr.asr_parakeet_mlx import transcribe_audio
-        model_name = "mlx-community/parakeet-tdt-0.6b-v2"
-        logger.info(f"使用Parakeet模型: {model_name}")
-    elif model == "distil-whisper":  # distil-whisper
-        from src.podcast_transcribe.asr.asr_distil_whisper_mlx import transcribe_audio
-        model_name = "mlx-community/distil-whisper-large-v3"
-        logger.info(f"使用Distil Whisper模型: {model_name}")
-    elif model == "distil-whisper-transformers":  # distil-whisper
-        from src.podcast_transcribe.asr.asr_distil_whisper_transformers import transcribe_audio
-        model_name = "distil-whisper/distil-large-v3.5"
-        logger.info(f"使用Distil Whisper模型: {model_name}")
-    else:
-        logger.error(f"错误：未指定模型类型")
-        return 1
-    
     try:
         print(f"正在加载音频文件: {audio_file}")
         # 加载音频文件
@@ -58,7 +43,7 @@ def main():
         
         # 进行转录
         print("开始转录...")
-        result = transcribe_audio(audio, model_name=model_name, device=device)
+        result = transcribe_audio(audio, model_name=model, device=device)
         
         # 输出结果
         print("\n转录结果:")

examples/simple_diarization.py

@@ -22,7 +22,6 @@ def main():
     audio_file = Path.joinpath(Path(__file__).parent, "input", "lex_ai_john_carmack_1.wav")  # 播客音频文件路径
     # audio_file = "/Users/konie/Desktop/voices/history_in_the_baking.mp3"  # 播客音频文件路径
     model_name = "pyannote/speaker-diarization-3.1"  # 说话人分离模型名称
-    hf_token = ""  # Hugging Face API 令牌
     device = "mps"  # 设备类型
     
     # 检查文件是否存在
@@ -30,11 +29,6 @@ def main():
         print(f"错误：文件 '{audio_file}' 不存在")
         return 1
     
-    # 检查令牌是否设置
-    if not hf_token:
-        print("错误：未设置HF_TOKEN环境变量，请设置后再运行")
-        return 1
-    
     try:
         print(f"正在加载音频文件: {audio_file}")
         # 加载音频文件
@@ -46,12 +40,12 @@ def main():
         if "pyannote/speaker-diarization" in model_name:
             # 使用transformers版本进行说话人分离
             print(f"使用transformers版本处理模型: {model_name}")
-            result = diarize_audio_transformers(audio, model_name=model_name, token=hf_token, device=device, segmentation_batch_size=128)
+            result = diarize_audio_transformers(audio, model_name=model_name, device=device, segmentation_batch_size=128)
             version_name = "Transformers"
         else:
             # 使用MLX版本进行说话人分离
             print(f"使用MLX版本处理模型: {model_name}")
-            result = diarize_audio_mlx(audio, model_name=model_name, token=hf_token, device=device, segmentation_batch_size=128)
+            result = diarize_audio_mlx(audio, model_name=model_name, device=device, segmentation_batch_size=128)
             version_name = "MLX"
         
         # 输出结果

requirements.txt

@@ -18,5 +18,4 @@ accelerate>=1.6.0
 # MLX特定依赖 - 仅适用于Apple Silicon Mac
 # mlx>=0.25.2
 # mlx-lm>=0.24.0
-# parakeet-mlx>=0.2.6
 # mlx-whisper>=0.4.2

src/podcast_transcribe/asr/asr_base.py

@@ -89,189 +89,4 @@ class BaseTranscriber:
         
         if chinese_chars > len(text) * 0.3:
             return "zh"
-        return "en"
-    
-    def _convert_segments(self, model_result) -> List[Dict[str, Union[float, str]]]:
-        """
-        将模型的分段结果转换为所需格式（需要在子类中实现）
-        
-        参数:
-            model_result: 模型返回的结果
-            
-        返回:
-            转换后的分段列表
-        """
-        raise NotImplementedError("子类必须实现_convert_segments方法")
-    
-    def transcribe(self, audio: AudioSegment, chunk_duration_s: int = 30, overlap_s: int = 5) -> TranscriptionResult:
-        """
-        转录音频，支持长音频分块处理。
-        
-        参数:
-            audio: 要转录的AudioSegment对象
-            chunk_duration_s: 分块处理的块时长（秒）。如果音频短于此，则不分块。
-            overlap_s: 分块间的重叠时长（秒）。
-            
-        返回:
-            TranscriptionResult对象，包含转录结果
-        """
-        logger.info(f"开始转录 {len(audio)/1000:.2f} 秒的音频。分块设置: 块时长={chunk_duration_s}s, 重叠={overlap_s}s")
-
-        if overlap_s >= chunk_duration_s and len(audio)/1000.0 > chunk_duration_s :
-            logger.error("重叠时长必须小于块时长。")
-            raise ValueError("overlap_s 必须小于 chunk_duration_s。")
-
-        total_duration_ms = len(audio)
-        chunk_duration_ms = chunk_duration_s * 1000
-        overlap_ms = overlap_s * 1000
-
-        if total_duration_ms <= chunk_duration_ms:
-            logger.debug("音频时长不大于设定块时长，直接进行完整转录。")
-            processed_audio = self._prepare_audio(audio)
-            samples = np.array(processed_audio.get_array_of_samples(), dtype=np.float32) / 32768.0
-            
-            try:
-                model_result = self._perform_transcription(samples)
-                text = self._get_text_from_result(model_result)
-                segments = self._convert_segments(model_result)
-                language = self._detect_language(text)
-                
-                logger.info(f"单块转录完成，语言: {language}，文本长度: {len(text)}，分段数: {len(segments)}")
-                return TranscriptionResult(text=text, segments=segments, language=language)
-            except Exception as e:
-                logger.error(f"单块转录失败: {str(e)}", exc_info=True)
-                raise RuntimeError(f"单块转录失败: {str(e)}")
-
-        # 长音频分块处理
-        final_segments = []
-        # current_pos_ms 指的是当前块要处理的"新内容"的起始点在原始音频中的位置
-        current_pos_ms = 0 
-
-        while current_pos_ms < total_duration_ms:
-            # 计算当前块实际送入模型处理的音频的起始和结束时间点
-            # 对于第一个块，start_process_ms = 0
-            # 对于后续块，start_process_ms 会向左回退 overlap_ms 以包含重叠区域
-            start_process_ms = max(0, current_pos_ms - overlap_ms)
-            end_process_ms = min(start_process_ms + chunk_duration_ms, total_duration_ms)
-
-            # 如果计算出的块起始点已经等于或超过总时长，说明处理完毕
-            if start_process_ms >= total_duration_ms:
-                break
-            
-            chunk_audio = audio[start_process_ms:end_process_ms]
-            
-            logger.info(f"处理音频块: {start_process_ms/1000.0:.2f}s - {end_process_ms/1000.0:.2f}s (新内容起始于: {current_pos_ms/1000.0:.2f}s)")
-
-            if len(chunk_audio) == 0:
-                logger.warning(f"生成了一个空的音频块，跳过。起始: {start_process_ms/1000.0:.2f}s, 结束: {end_process_ms/1000.0:.2f}s")
-                # 必须推进 current_pos_ms 以避免死循环
-                advance_ms = chunk_duration_ms - overlap_ms
-                if advance_ms <= 0: # 应该在函数开始时已检查 overlap_s < chunk_duration_s
-                    raise RuntimeError("块推进时长配置错误，可能导致死循环。")
-                current_pos_ms += advance_ms
-                continue
-
-            processed_chunk_audio = self._prepare_audio(chunk_audio)
-            samples = np.array(processed_chunk_audio.get_array_of_samples(), dtype=np.float32) / 32768.0
-            
-            try:
-                model_result = self._perform_transcription(samples)
-                segments_chunk = self._convert_segments(model_result)
-
-                for seg in segments_chunk:
-                    # seg["start"] 和 seg["end"] 是相对于当前块 (chunk_audio) 的起始点（即0）
-                    # 计算 segment 在原始完整音频中的绝对起止时间
-                    global_seg_start_s = start_process_ms / 1000.0 + seg["start"]
-                    global_seg_end_s = start_process_ms / 1000.0 + seg["end"]
-                    
-                    # ��心去重逻辑：
-                    # 我们只接受那些真实开始于 current_pos_ms / 1000.0 之后的 segment。
-                    # current_pos_ms 是当前块应该贡献的"新"内容的开始时间。
-                    # 对于第一个块 (current_pos_ms == 0)，所有 segment 都被接受（只要它们的 start >= 0）。
-                    # 对于后续块，只有当 segment 的全局开始时间 >= 当前块新内容的开始时间时，才添加。
-                    if global_seg_start_s >= current_pos_ms / 1000.0:
-                        final_segments.append({
-                            "start": global_seg_start_s,
-                            "end": global_seg_end_s,
-                            "text": seg["text"]
-                        })
-                    # 特殊处理第一个块，因为 current_pos_ms 为 0，上面的条件 global_seg_start_s >= 0 总是满足。
-                    # 但为了更清晰，如果不是第一个块，但 segment 跨越了 current_pos_ms,
-                    # 它的起始部分在重叠区，结束部分在非重叠区。
-                    # 当前逻辑是，如果它的 global_seg_start_s < current_pos_ms / 1000.0，它就被丢弃。
-                    # 这是为了确保不重复记录重叠区域的开头部分。
-                    # 如果一个 segment 完全在重叠区内且在前一个块已被记录，此逻辑可避免重复。
-
-            except Exception as e:
-                logger.error(f"处理音频块 {start_process_ms/1000.0:.2f}s - {end_process_ms/1000.0:.2f}s 失败: {str(e)}", exc_info=True)
-            
-            # 更新下一个"新内容"块的起始位置
-            advance_ms = chunk_duration_ms - overlap_ms
-            current_pos_ms += advance_ms
-        
-        # 对收集到的所有 segments 按开始时间排序
-        final_segments.sort(key=lambda s: s["start"])
-
-        # 可选：进一步清理 segments，例如合并非常接近且文本连续的，或移除完全重复的
-        cleaned_segments = []
-        if final_segments:
-            cleaned_segments.append(final_segments[0])
-            for i in range(1, len(final_segments)):
-                prev_s = cleaned_segments[-1]
-                curr_s = final_segments[i]
-                # 简单的去重：如果时间戳和文本都几乎一样，则认为是重复
-                if abs(curr_s["start"] - prev_s["start"]) < 0.01 and \
-                   abs(curr_s["end"] - prev_s["end"]) < 0.01 and \
-                   curr_s["text"] == prev_s["text"]:
-                    continue
-                
-                # 如果当前 segment 的开始时间在前一个 segment 的结束时间之前，
-                # 并且文本有明显重叠，可能需要更智能的合并。
-                # 目前的逻辑通过 global_seg_start_s >= current_pos_ms / 1000.0 过滤，
-                # 已经大大减少了直接的 segment 重复。
-                # 此处的清理更多是处理模型在边界可能产生的一些微小偏差。
-                # 如果上一个segment的结束时间比当前segment的开始时间还要晚，说明有重叠，
-                # 且上一个segment包含了当前segment的开始部分。
-                # 这种情况下，可以考虑调整上一个的结束，或当前segment的开始和文本。
-                # 为简单起见，暂时直接添加，相信之前的过滤已处理主要重叠。
-                if curr_s["start"] < prev_s["end"] and prev_s["text"].endswith(curr_s["text"][:len(prev_s["text"]) - int((prev_s["end"] - curr_s["start"])*10) ]): # 粗略检查
-                     # 如果curr_s的开始部分被prev_s覆盖，并且文本也对应，则调整curr_s
-                     # pass # 暂时不处理这种细微重叠，依赖模型切分
-                     cleaned_segments.append(curr_s) # 仍添加，依赖后续文本拼接
-                else:
-                    cleaned_segments.append(curr_s)
-        
-        final_text = " ".join([s["text"] for s in cleaned_segments]).strip()
-        language = self._detect_language(final_text)
-        
-        logger.info(f"分块转录完成。最终文本长度: {len(final_text)}, 分段数: {len(cleaned_segments)}")
-        
-        return TranscriptionResult(
-            text=final_text,
-            segments=cleaned_segments,
-            language=language
-        )
-            
-    def _perform_transcription(self, audio_data):
-        """
-        执行转录（需要在子类中实现）
-        
-        参数:
-            audio_data: 音频数据（numpy数组）
-            
-        返回:
-            模型的转录结果
-        """
-        raise NotImplementedError("子类必须实现_perform_transcription方法")
-    
-    def _get_text_from_result(self, result):
-        """
-        从结果中获取文本（需要在子类中实现）
-        
-        参数:
-            result: 模型的转录结果
-            
-        返回:
-            ���录的文本
-        """
-        raise NotImplementedError("子类必须实现_get_text_from_result方法") 
+        return "en"

src/podcast_transcribe/asr/asr_distil_whisper.py

@@ -0,0 +1,319 @@
+"""
+基于MLX或Transformers实现的语音识别模块，使用distil-whisper模型
+"""
+
+import os
+from pydub import AudioSegment
+from typing import Dict, List, Union, Literal
+import logging
+import numpy as np
+
+# 导入基类
+from .asr_base import BaseTranscriber, TranscriptionResult
+
+# 配置日志
+logger = logging.getLogger("asr")
+
+
+class DistilWhisperTranscriber(BaseTranscriber):
+    """抽象基类：Distil Whisper转录器的共享实现"""
+    
+    def __init__(
+        self, 
+        model_name: str,
+        **kwargs
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+            **kwargs: 其他参数
+        """
+        super().__init__(model_name=model_name, **kwargs)
+    
+    def transcribe(self, audio: AudioSegment) -> TranscriptionResult:
+        """
+        转录音频，针对distil-whisper模型取消分块处理，直接处理整个音频。
+        
+        参数:
+            audio: 要转录的AudioSegment对象
+            chunk_duration_s: 分块处理的块时长（秒）- 此参数被忽略
+            overlap_s: 分块间的重叠时长（秒）- 此参数被忽略
+            
+        返回:
+            TranscriptionResult对象，包含转录结果
+        """
+        logger.info(f"开始转录 {len(audio)/1000:.2f} 秒的音频（distil-whisper模型）")
+        
+        # 直接处理整个音频，不进行分块
+        processed_audio = self._prepare_audio(audio)
+        samples = np.array(processed_audio.get_array_of_samples(), dtype=np.float32) / 32768.0
+        
+        try:
+            model_result = self._perform_transcription(samples)
+            text = self._get_text_from_result(model_result)
+            segments = self._convert_segments(model_result)
+            language = self._detect_language(text)
+            
+            logger.info(f"转录完成，语言: {language}，文本长度: {len(text)}，分段数: {len(segments)}")
+            return TranscriptionResult(text=text, segments=segments, language=language)
+        except Exception as e:
+            logger.error(f"转录失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"转录失败: {str(e)}")
+    
+    def _get_text_from_result(self, result):
+        """
+        从结果中获取文本
+        
+        参数:
+            result: 模型的转录结果
+            
+        返回:
+            转录的文本
+        """
+        return result.get("text", "")
+    
+    def _load_model(self):
+        """加载模型的抽象方法，由子类实现"""
+        raise NotImplementedError("子类必须实现_load_model方法")
+    
+    def _perform_transcription(self, audio_data):
+        """执行转录的抽象方法，由子类实现"""
+        raise NotImplementedError("子类必须实现_perform_transcription方法")
+    
+    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
+        """将模型结果转换为分段的抽象方法，由子类实现"""
+        raise NotImplementedError("子类必须实现_convert_segments方法")
+
+
+class MLXDistilWhisperTranscriber(DistilWhisperTranscriber):
+    """使用MLX加载和运行distil-whisper模型的转录器"""
+    
+    def __init__(
+        self, 
+        model_name: str = "mlx-community/distil-whisper-large-v3",
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+        """
+        super().__init__(model_name=model_name)
+        
+    def _load_model(self):
+        """加载Distil Whisper MLX模型"""
+        try:
+            # 懒加载mlx-whisper
+            try:
+                import mlx_whisper
+            except ImportError:
+                raise ImportError("请先安装mlx-whisper库: pip install mlx-whisper")
+                
+            logger.info(f"开始加载模型 {self.model_name}")
+            self.model = mlx_whisper.load_models.load_model(self.model_name)
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式
+        
+        参数:
+            result: 模型返回的结果
+            
+        返回:
+            转换后的分段列表
+        """
+        segments = []
+        
+        for segment in result.get("segments", []):
+            segments.append({
+                "start": segment.get("start", 0.0),
+                "end": segment.get("end", 0.0),
+                "text": segment.get("text", "").strip()
+            })
+        
+        return segments
+    
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        from mlx_whisper import transcribe
+        return transcribe(audio_data, path_or_hf_repo=self.model_name)
+
+
+class TransformersDistilWhisperTranscriber(DistilWhisperTranscriber):
+    """使用Transformers加载和运行distil-whisper模型的转录器"""
+    
+    def __init__(
+        self, 
+        model_name: str = "distil-whisper/distil-large-v3.5",
+        device: str = "cpu",
+    ):
+        """
+        初始化转录器
+        
+        参数:
+            model_name: 模型名称
+            device: 推理设备，'cpu'或'cuda'
+        """
+        super().__init__(model_name=model_name, device=device)
+        
+    def _load_model(self):
+        """加载Distil Whisper Transformers模型"""
+        try:
+            # 懒加载transformers
+            try:
+                from transformers import pipeline
+            except ImportError:
+                raise ImportError("请先安装transformers库: pip install transformers")
+                
+            logger.info(f"开始加载模型 {self.model_name} 设备: {self.device}")
+
+            pipeline_device_arg = None
+            if self.device == "cuda":
+                pipeline_device_arg = 0  # 使用第一个 CUDA 设备
+            elif self.device == "mps":
+                pipeline_device_arg = "mps"  # 使用 MPS 设备
+            elif self.device == "cpu":
+                pipeline_device_arg = -1 # 使用 CPU
+            else:
+                # 对于其他未明确支持的 device 字符串，记录警告并默认使用 CPU
+                logger.warning(f"不支持的设备字符串 '{self.device}'，将默认使用 CPU。")
+                pipeline_device_arg = -1
+            
+            # 导入必要的模块来配置模型
+            import warnings
+            from transformers import AutoProcessor, AutoModelForSpeechSeq2Seq
+            
+            # 抑制特定的警告
+            warnings.filterwarnings("ignore", message="The input name `inputs` is deprecated")
+            warnings.filterwarnings("ignore", message="You have passed task=transcribe")
+            warnings.filterwarnings("ignore", message="The attention mask is not set")
+            
+            self.pipeline = pipeline(
+                "automatic-speech-recognition",
+                model=self.model_name,
+                device=pipeline_device_arg,
+                return_timestamps=True,
+                chunk_length_s=30,      # 使用30秒的块长度
+                stride_length_s=5,      # 块之间5秒的重叠
+                batch_size=1,           # 顺序处理
+                # 添加以下参数来减少警告
+                generate_kwargs={
+                    "task": "transcribe",
+                    "language": None,  # 自动检测语言
+                    "forced_decoder_ids": None,  # 避免冲突
+                }
+            )
+            logger.info(f"模型加载成功")
+        except Exception as e:
+            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
+            raise RuntimeError(f"加载模型失败: {str(e)}")
+    
+    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
+        """
+        将模型的分段结果转换为所需格式
+        
+        参数:
+            result: 模型返回的结果
+            
+        返回:
+            转换后的分段列表
+        """
+        segments = []
+        
+        # transformers pipeline 的结果格式
+        if "chunks" in result:
+            for chunk in result["chunks"]:
+                segments.append({
+                    "start": chunk["timestamp"][0] if chunk["timestamp"][0] is not None else 0.0,
+                    "end": chunk["timestamp"][1] if chunk["timestamp"][1] is not None else 0.0,
+                    "text": chunk["text"].strip()
+                })
+        else:
+            # 如果没有分段信息，创建一个单一分段
+            segments.append({
+                "start": 0.0,
+                "end": 0.0,  # 无法确定结束时间
+                "text": result.get("text", "").strip()
+            })
+        
+        return segments
+    
+    def _perform_transcription(self, audio_data):
+        """
+        执行转录
+        
+        参数:
+            audio_data: 音频数据（numpy数组）
+            
+        返回:
+            模型的转录结果
+        """
+        # transformers pipeline 接受numpy数组作为输入
+        # 音频数据已经在_prepare_audio中确保是16kHz采样率
+        
+        # 确保音频数据格式正确
+        if audio_data.dtype != np.float32:
+            audio_data = audio_data.astype(np.float32)
+        
+        # 使用正确的参数名称调用pipeline
+        try:
+            result = self.pipeline(
+                audio_data,
+                generate_kwargs={
+                    "task": "transcribe",
+                    "language": None,  # 自动检测语言
+                    "forced_decoder_ids": None,  # 避免冲突
+                }
+            )
+            return result
+        except Exception as e:
+            logger.warning(f"使用新参数格式失败，尝试使用默认参数: {str(e)}")
+            # 如果新格式失败，回退到简单调用
+            return self.pipeline(audio_data)
+
+
+# 统一的接口函数
+def transcribe_audio(
+    audio_segment: AudioSegment,
+    model_name: str = None,
+    backend: Literal["mlx", "transformers"] = "transformers",
+    device: str = "cpu",
+) -> TranscriptionResult:
+    """
+    使用Distil Whisper模型转录音频
+    
+    参数:
+        audio_segment: 输入的AudioSegment对象
+        model_name: 使用的模型名称，如果不指定则使用默认模型
+        backend: 后端类型，'mlx'或'transformers'
+        device: 推理设备，仅对transformers后端有效
+        
+    返回:
+        TranscriptionResult对象，包含转录的文本、分段和语言
+    """
+    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒，后端: {backend}")
+    
+    if backend == "mlx":
+        default_model = "mlx-community/distil-whisper-large-v3"
+        model = model_name or default_model
+        transcriber = MLXDistilWhisperTranscriber(model_name=model)
+    else:  # transformers
+        default_model = "distil-whisper/distil-large-v3.5"
+        model = model_name or default_model
+        transcriber = TransformersDistilWhisperTranscriber(model_name=model, device=device)
+    
+    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_distil_whisper_mlx.py

@@ -1,111 +0,0 @@
-"""
-基于MLX实现的语音识别模块，使用distil-whisper-large-v3模型
-"""
-
-import os
-from pydub import AudioSegment
-from typing import Dict, List, Union
-import logging
-
-# 导入基类
-from .asr_base import BaseTranscriber, TranscriptionResult
-
-# 配置日志
-logger = logging.getLogger("asr")
-
-
-class MLXDistilWhisperTranscriber(BaseTranscriber):
-    """使用MLX加载和运行distil-whisper-large-v3模型的转录器"""
-    
-    def __init__(
-        self, 
-        model_name: str = "mlx-community/distil-whisper-large-v3",
-    ):
-        """
-        初始化转录器
-        
-        参数:
-            model_name: 模型名称
-        """
-        super().__init__(model_name=model_name)
-        
-    def _load_model(self):
-        """加载Distil Whisper模型"""
-        try:
-            # 懒加载mlx-whisper
-            try:
-                import mlx_whisper
-            except ImportError:
-                raise ImportError("请先安装mlx-whisper库: pip install mlx-whisper")
-                
-            logger.info(f"开始加载模型 {self.model_name}")
-            self.model = mlx_whisper.load_models.load_model(self.model_name)
-            logger.info(f"模型加载成功")
-        except Exception as e:
-            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
-            raise RuntimeError(f"加载模型失败: {str(e)}")
-    
-    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
-        """
-        将模型的分段结果转换为所需格式
-        
-        参数:
-            result: 模型返回的结果
-            
-        返回:
-            转换后的分段列表
-        """
-        segments = []
-        
-        for segment in result.get("segments", []):
-            segments.append({
-                "start": segment.get("start", 0.0),
-                "end": segment.get("end", 0.0),
-                "text": segment.get("text", "").strip()
-            })
-        
-        return segments
-    
-    def _perform_transcription(self, audio_data):
-        """
-        执行转录
-        
-        参数:
-            audio_data: 音频数据（numpy数组）
-            
-        返回:
-            模型的转录结果
-        """
-        from mlx_whisper import transcribe
-        return transcribe(audio_data, path_or_hf_repo=self.model_name)
-    
-    def _get_text_from_result(self, result):
-        """
-        从结果中获取文本
-        
-        参数:
-            result: 模型的转录结果
-            
-        返回:
-            转录的文本
-        """
-        return result.get("text", "")
-
-
-def transcribe_audio(
-    audio_segment: AudioSegment,
-    model_name: str = "mlx-community/distil-whisper-large-v3",
-) -> TranscriptionResult:
-    """
-    使用MLX和distil-whisper-large-v3模型转录音频
-    
-    参数:
-        audio_segment: 输入的AudioSegment对象
-        model_name: 使用的模型名称
-        
-    返回:
-        TranscriptionResult对象，包含转录的文本、分段和语言
-    """
-    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
-    transcriber = MLXDistilWhisperTranscriber(model_name=model_name)
-    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_distil_whisper_transformers.py

@@ -1,133 +0,0 @@
-"""
-基于Transformers实现的语音识别模块，使用distil-whisper-large-v3.5模型
-"""
-
-import os
-from pydub import AudioSegment
-from typing import Dict, List, Union
-import logging
-import numpy as np
-
-# 导入基类
-from .asr_base import BaseTranscriber, TranscriptionResult
-
-# 配置日志
-logger = logging.getLogger("asr")
-
-
-class TransformersDistilWhisperTranscriber(BaseTranscriber):
-    """使用Transformers加载和运行distil-whisper-large-v3.5模型的转录器"""
-    
-    def __init__(
-        self, 
-        model_name: str = "distil-whisper/distil-large-v3.5",
-        device: str = "cpu",
-    ):
-        """
-        初始化转录器
-        
-        参数:
-            model_name: 模型名称
-            device: 推理设备，'cpu'或'cuda'
-        """
-        super().__init__(model_name=model_name, device=device)
-        
-    def _load_model(self):
-        """加载Distil Whisper模型"""
-        try:
-            # 懒加载transformers
-            try:
-                from transformers import pipeline
-            except ImportError:
-                raise ImportError("请先安装transformers库: pip install transformers")
-                
-            logger.info(f"开始加载模型 {self.model_name}")
-            self.pipeline = pipeline(
-                "automatic-speech-recognition",
-                model=self.model_name,
-                device=0 if self.device == "cuda" else -1,
-                return_timestamps=True,
-                chunk_length_s=25,
-                batch_size=32,
-            )
-            logger.info(f"模型加载成功")
-        except Exception as e:
-            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
-            raise RuntimeError(f"加载模型失败: {str(e)}")
-    
-    def _convert_segments(self, result) -> List[Dict[str, Union[float, str]]]:
-        """
-        将模型的分段结果转换为所需格式
-        
-        参数:
-            result: 模型返回的结果
-            
-        返回:
-            转换后的分段列表
-        """
-        segments = []
-        
-        # transformers pipeline 的结果格式
-        if "chunks" in result:
-            for chunk in result["chunks"]:
-                segments.append({
-                    "start": chunk["timestamp"][0] if chunk["timestamp"][0] is not None else 0.0,
-                    "end": chunk["timestamp"][1] if chunk["timestamp"][1] is not None else 0.0,
-                    "text": chunk["text"].strip()
-                })
-        else:
-            # 如果没有分段信息，创建一个单一分段
-            segments.append({
-                "start": 0.0,
-                "end": 0.0,  # 无法确定结束时间
-                "text": result.get("text", "").strip()
-            })
-        
-        return segments
-    
-    def _perform_transcription(self, audio_data):
-        """
-        执行转录
-        
-        参数:
-            audio_data: 音频数据（numpy数组）
-            
-        返回:
-            模型的转录结果
-        """
-        # transformers pipeline 接受numpy数组作为输入
-        # 音频数据已经在_prepare_audio中确保是16kHz采样率
-        return self.pipeline(audio_data)
-    
-    def _get_text_from_result(self, result):
-        """
-        从结果中获取文本
-        
-        参数:
-            result: 模型的转录结果
-            
-        返回:
-            转录的文本
-        """
-        return result.get("text", "")
-
-
-def transcribe_audio(
-    audio_segment: AudioSegment,
-    model_name: str = "distil-whisper/distil-large-v3.5",
-    device: str = "cpu",
-) -> TranscriptionResult:
-    """
-    使用Transformers和distil-whisper-large-v3.5模型转录音频
-    
-    参数:
-        audio_segment: 输入的AudioSegment对象
-        model_name: 使用的模型名称
-        device: 推理设备，'cpu'或'cuda'
-        
-    返回:
-        TranscriptionResult对象，包含转录的文本、分段和语言
-    """
-    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
-    transcriber = TransformersDistilWhisperTranscriber(model_name=model_name, device=device)
-    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_parakeet_mlx.py

@@ -1,126 +0,0 @@
-"""
-基于MLX实现的语音识别模块，使用parakeet-tdt模型
-"""
-
-import os
-from pydub import AudioSegment
-from typing import Dict, List, Union
-import logging
-import tempfile
-import numpy as np
-import soundfile as sf
-
-# 导入基类
-from .asr_base import BaseTranscriber, TranscriptionResult
-
-# 配置日志
-logger = logging.getLogger("asr")
-
-
-class MLXParakeetTranscriber(BaseTranscriber):
-    """使用MLX加载和运行parakeet-tdt-0.6b-v2模型的转录器"""
-    
-    def __init__(
-        self, 
-        model_name: str = "mlx-community/parakeet-tdt-0.6b-v2",
-    ):
-        """
-        初始化转录器
-        
-        参数:
-            model_name: 模型名称
-        """
-        super().__init__(model_name=model_name)
-    
-    def _load_model(self):
-        """加载Parakeet模型"""
-        try:
-            # 懒加载parakeet_mlx
-            try:
-                from parakeet_mlx import from_pretrained
-            except ImportError:
-                raise ImportError("请先安装parakeet-mlx库: pip install parakeet-mlx")
-                
-            logger.info(f"开始加载模型 {self.model_name}")
-            self.model = from_pretrained(self.model_name)
-            logger.info(f"模型加载成功")
-        except Exception as e:
-            logger.error(f"加载模型失败: {str(e)}", exc_info=True)
-            raise RuntimeError(f"加载模型失败: {str(e)}")
-    
-    def _convert_segments(self, aligned_result) -> List[Dict[str, Union[float, str]]]:
-        """
-        将模型的分段结果转换为所需格式
-        
-        参数:
-            aligned_result: 模型返回的分段结果
-            
-        返回:
-            转换后的分段列表
-        """
-        segments = []
-        
-        for sentence in aligned_result.sentences:
-            segments.append({
-                "start": sentence.start,
-                "end": sentence.end,
-                "text": sentence.text
-            })
-        
-        return segments
-    
-    def _perform_transcription(self, audio_data):
-        """
-        执行转录
-        
-        参数:
-            audio_data: 音频数据（numpy数组）
-            
-        返回:
-            模型的转录结果
-        """
-        # 由于parakeet-mlx可能不直接支持numpy数组输入
-        # 创建临时文件并写入音频数据
-        with tempfile.NamedTemporaryFile(suffix='.wav', delete=True) as temp_file:
-            # 确保数据在[-1, 1]范围内
-            if audio_data.max() > 1.0 or audio_data.min() < -1.0:
-                audio_data = np.clip(audio_data, -1.0, 1.0)
-            
-            # 写入临时文件
-            sf.write(temp_file.name, audio_data, 16000, 'PCM_16')
-            
-            # 使用临时文件进行转录
-            result = self.model.transcribe(temp_file.name)
-        
-        return result
-    
-    def _get_text_from_result(self, result):
-        """
-        从结果中获取文本
-        
-        参数:
-            result: 模型的转录结果
-            
-        返回:
-            转录的文本
-        """
-        return result.text
-
-
-def transcribe_audio(
-    audio_segment: AudioSegment,
-    model_name: str = "mlx-community/parakeet-tdt-0.6b-v2",
-) -> TranscriptionResult:
-    """
-    使用MLX和parakeet-tdt模型转录音频
-    
-    参数:
-        audio_segment: 输入的AudioSegment对象
-        model_name: 使用的模型名称
-        
-    返回:
-        TranscriptionResult对象，包含转录的文本、分段和语言
-    """
-    logger.info(f"调用transcribe_audio函数，音频长度: {len(audio_segment)/1000:.2f}秒")
-    transcriber = MLXParakeetTranscriber(model_name=model_name)
-    return transcriber.transcribe(audio_segment)

src/podcast_transcribe/asr/asr_router.py

@@ -4,13 +4,11 @@ ASR模型调用路由器
 """
 
 import logging
-from typing import Dict, Any, Optional, Callable
+from typing import Dict, Any, Literal, Optional, Callable
 from pydub import AudioSegment
 import spaces
 from .asr_base import TranscriptionResult
-from . import asr_parakeet_mlx
-from . import asr_distil_whisper_mlx
-from . import asr_distil_whisper_transformers
+from . import asr_distil_whisper
 
 # 配置日志
 logger = logging.getLogger("asr")
@@ -26,22 +24,8 @@ class ASRRouter:
         
         # 定义支持的provider配置
         self._provider_configs = {
-            "parakeet_mlx": {
-                "module_path": "asr_parakeet_mlx",
-                "function_name": "transcribe_audio",
-                "default_model": "mlx-community/parakeet-tdt-0.6b-v2",
-                "supported_params": ["model_name"],
-                "description": "基于MLX的Parakeet模型"
-            },
-            "distil_whisper_mlx": {
-                "module_path": "asr_distil_whisper_mlx", 
-                "function_name": "transcribe_audio",
-                "default_model": "mlx-community/distil-whisper-large-v3",
-                "supported_params": ["model_name"],
-                "description": "基于MLX的Distil Whisper模型"
-            },
             "distil_whisper_transformers": {
-                "module_path": "asr_distil_whisper_transformers",
+                "module_path": "asr_distil_whisper",
                 "function_name": "transcribe_audio", 
                 "default_model": "distil-whisper/distil-large-v3.5",
                 "supported_params": ["model_name", "device"],
@@ -66,15 +50,8 @@ class ASRRouter:
             module_path = self._provider_configs[provider]["module_path"]
             logger.info(f"获取模块: {module_path}")
             
-            # 根据module_path返回对应的模块
-            if module_path == "asr_parakeet_mlx":
-                module = asr_parakeet_mlx
-            elif module_path == "asr_distil_whisper_mlx":
-                module = asr_distil_whisper_mlx
-            elif module_path == "asr_distil_whisper_transformers":
-                module = asr_distil_whisper_transformers
-            else:
-                raise ImportError(f"未找到模块: {module_path}")
+            # 所有provider现在都指向同一个模块
+            module = asr_distil_whisper
             
             self._loaded_modules[provider] = module
             logger.info(f"模块 {module_path} 获取成功")
@@ -202,51 +179,17 @@ def transcribe_audio(
     provider: str = "distil_whisper_transformers",
     model_name: Optional[str] = None,
     device: str = "cpu",
+    backend: str = "transformers",
     **kwargs
 ) -> TranscriptionResult:
-    """
-    统一的音频转录接口函数
-    
-    参数:
-        audio_segment: 输入的AudioSegment对象
-        provider: ASR提供者，可选值：
-            - "parakeet_mlx": 基于MLX的Parakeet模型
-            - "distil_whisper_mlx": 基于MLX的Distil Whisper模型  
-            - "distil_whisper_transformers": 基于Transformers的Distil Whisper模型
-        model_name: 模型名称，如果不指定则使用默认模型
-        device: 推理设备，仅对transformers provider有效
-        **kwargs: 其他参数
-        
-    返回:
-        TranscriptionResult对象，包含转录的文本、分段和语言
-        
-    示例:
-        # 使用默认MLX Distil Whisper模型
-        result = transcribe_audio(audio_segment, provider="distil_whisper_mlx")
-        
-        # 使用Parakeet模型
-        result = transcribe_audio(audio_segment, provider="parakeet_mlx")
-        
-        # 使用Transformers模型并指定设备
-        result = transcribe_audio(
-            audio_segment, 
-            provider="distil_whisper_transformers",
-            device="cuda"
-        )
-        
-        # 使用自定义模型
-        result = transcribe_audio(
-            audio_segment,
-            provider="distil_whisper_mlx", 
-            model_name="mlx-community/whisper-large-v3"
-        )
-    """
     # 准备参数
     params = kwargs.copy()
     if model_name is not None:
         params["model_name"] = model_name
     if device != "cpu":
         params["device"] = device
+    if backend is not None:
+        params["backend"] = backend
     
     return _router.transcribe(audio_segment, provider, **params)
 

src/podcast_transcribe/diarization/diarization_pyannote_mlx.py

@@ -48,9 +48,6 @@ class PyannoteTranscriber(BaseDiarizer):
             except ImportError:
                 raise ImportError("请先安装pyannote.audio库: pip install pyannote.audio")
                 
-            if not self.token:
-                raise ValueError("需要提供Hugging Face令牌才能使用pyannote模型。请通过参数传入或设置HF_TOKEN环境变量。")
-                
             logger.info(f"开始加载模型 {self.model_name}")
             self.pipeline = Pipeline.from_pretrained(
                 self.model_name,

src/podcast_transcribe/diarization/diarization_pyannote_transformers.py

@@ -48,10 +48,7 @@ class PyannoteTransformersTranscriber(BaseDiarizer):
                 from pyannote.audio import Pipeline
             except ImportError:
                 raise ImportError("请先安装pyannote.audio库: pip install pyannote.audio")
-                
-            if not self.token:
-                raise ValueError("需要提供Hugging Face令牌才能使用pyannote模型。请通过参数传入或设置HF_TOKEN环境变量。")
-                
+    
             logger.info(f"开始使用pyannote.audio加载模型 {self.model_name}")
             
             # 使用pyannote.audio Pipeline加载说话人分离模型

src/podcast_transcribe/diarization/diarizer_base.py

@@ -34,7 +34,6 @@ class BaseDiarizer(ABC):
             segmentation_batch_size: 分割批处理大小，默认为32
         """
         self.model_name = model_name
-        self.token = token or os.environ.get("HF_TOKEN")
         self.device = device
         self.segmentation_batch_size = segmentation_batch_size
         

src/podcast_transcribe/diarization/diarizer_router.py

@@ -215,20 +215,18 @@ def diarize_audio(
         
     示例:
         # 使用默认pyannote MLX实现
-        result = diarize_audio(audio_segment, provider="pyannote_mlx", token="your_hf_token")
+        result = diarize_audio(audio_segment, provider="pyannote_mlx")
         
         # 使用transformers实现
         result = diarize_audio(
             audio_segment, 
             provider="pyannote_transformers",
-            token="your_hf_token"
         )
         
         # 使用GPU设备
         result = diarize_audio(
             audio_segment,
             provider="pyannote_mlx",
-            token="your_hf_token",
             device="cuda"
         )
         
@@ -236,7 +234,6 @@ def diarize_audio(
         result = diarize_audio(
             audio_segment,
             provider="pyannote_mlx", 
-            token="your_hf_token",
             segmentation_batch_size=64
         )
     """

src/podcast_transcribe/transcriber.py

@@ -31,7 +31,6 @@ class CombinedTranscriber:
         diarization_model_name: str,
         llm_model_name: Optional[str] = None,
         llm_provider: Optional[str] = None,
-        hf_token: Optional[str] = None,
         device: Optional[str] = None,
         segmentation_batch_size: int = 64,
         parallel: bool = False,
@@ -44,7 +43,6 @@ class CombinedTranscriber:
             asr_provider: ASR提供者名称
             diarization_provider: 说话人分离提供者名称
             diarization_model_name: 说话人分离模型名称
-            hf_token: Hugging Face令牌
             device: 推理设备，'cpu'或'cuda'
             segmentation_batch_size: 分割批处理大小，默认为64
             parallel: 是否并行执行ASR和说话人分离，默认为False
@@ -75,7 +73,6 @@ class CombinedTranscriber:
         self.asr_provider = asr_provider
         self.diarization_provider = diarization_provider
         self.diarization_model_name = diarization_model_name
-        self.hf_token = hf_token or os.environ.get("HF_TOKEN")
         self.device = device
         self.segmentation_batch_size = segmentation_batch_size
         self.parallel = parallel
@@ -148,7 +145,6 @@ class CombinedTranscriber:
             audio,
             provider=self.diarization_provider,
             model_name=self.diarization_model_name,
-            token=self.hf_token,
             device=self.device,
             segmentation_batch_size=self.segmentation_batch_size
         )
@@ -195,7 +191,6 @@ class CombinedTranscriber:
                 audio,
                 provider=self.diarization_provider,
                 model_name=self.diarization_model_name,
-                token=self.hf_token,
                 device=self.device,
                 segmentation_batch_size=self.segmentation_batch_size
             )
@@ -491,7 +486,6 @@ def transcribe_audio(
     asr_provider: str = "distil_whisper_transformers",
     diarization_model_name: str = "pyannote/speaker-diarization-3.1",
     diarization_provider: str = "pyannote_transformers",
-    hf_token: Optional[str] = None,
     device: Optional[str] = None,
     segmentation_batch_size: int = 64,
     parallel: bool = False,
@@ -505,7 +499,6 @@ def transcribe_audio(
         asr_provider: ASR提供者名称
         diarization_model_name: 说话人分离模型名称
         diarization_provider: 说话人分离提供者名称
-        hf_token: Hugging Face令牌
         device: 推理设备，'cpu'或'cuda'
         segmentation_batch_size: 分割批处理大小，默认为64
         parallel: 是否并行执行ASR和说话人分离，默认为False
@@ -520,7 +513,6 @@ def transcribe_audio(
         asr_provider=asr_provider,
         diarization_model_name=diarization_model_name,
         diarization_provider=diarization_provider,
-        hf_token=hf_token,
         device=device,
         segmentation_batch_size=segmentation_batch_size,
         parallel=parallel
@@ -539,7 +531,6 @@ def transcribe_podcast_audio(
     diarization_provider: str = "pyannote_transformers",
     llm_model_name: Optional[str] = None,
     llm_provider: Optional[str] = None,
-    hf_token: Optional[str] = None,
     device: Optional[str] = None,
     segmentation_batch_size: int = 64,
     parallel: bool = False,
@@ -557,7 +548,6 @@ def transcribe_podcast_audio(
         diarization_model_name: 说话人分离模型名称
         llm_model_name: LLM模型名称，如果为None则无法识别说话人名称
         llm_provider: LLM提供者名称，如果为None则无法识别说话人名称
-        hf_token: Hugging Face令牌
         device: 推理设备，'cpu'或'cuda'
         segmentation_batch_size: 分割批处理大小，默认为64
         parallel: 是否并行执行ASR和说话人分离，默认为False
@@ -574,7 +564,6 @@ def transcribe_podcast_audio(
         diarization_model_name=diarization_model_name,
         llm_model_name=llm_model_name,
         llm_provider=llm_provider,
-        hf_token=hf_token,
         device=device,
         segmentation_batch_size=segmentation_batch_size,
         parallel=parallel