初始提交 - 不包含二進制檔案

.gitattributes

@@ -0,0 +1,37 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.wav filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,65 @@
+# Python 虛擬環境
+env/
+env_new/
+env_old/
+venv/
+ENV/
+.env
+.venv
+*env*/      # 匹配所有包含 'env' 的資料夾
+
+# Python 快取檔案
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+
+# 分發/打包
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# 單元測試/覆蓋率報告
+htmlcov/
+.tox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# PyCharm, VSCode 等 IDE 設定
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# 操作系統相關
+.DS_Store
+Thumbs.db
+
+# 專案特定
+*.log
+*.sqlite3
+"assets/*.wav" 
+"assets/*.mp3" 
+"env/" 

README.md

@@ -0,0 +1,49 @@
+---
+title: Automatic Speech Recognition Speech To Text
+emoji: 🔊🔄📝
+colorFrom: red
+colorTo: yellow
+sdk: gradio
+sdk_version: 5.26.0
+app_file: app.py
+pinned: false
+license: apache-2.0
+short_description: Automatic-Speech-Recognition-Speech-to-Text
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+# Clone repository
+git clone https://huggingface.co/spaces/hchcsuim/Automatic-Speech-Recognition-Speech-to-Text
+cd Automatic-Speech-Recognition-Speech-to-Text
+
+# windows 安裝 ffmpeg
+https://ffmpeg.org/download.html
+下載版本 ffmpeg-git-full.7z
+解壓縮到 C:\ffmpeg
+加入環境變數 系統變數 path C:\ffmpeg\bin
+
+# 要在電腦環境先安裝 python 3.10
+
+# Create and activate Python environment
+python -m venv env
+source env/bin/activate # for linux
+env\Scripts\activate # for windows
+
+# 或者在 vscode 手動切換預設環境
+Ctrl+Shift+P
+Python: Select Interpreter
+
+# Install dependencies
+# requirements.txt is for Hugging Face Spaces
+pip install -r requirements_local.txt
+
+# 驗證 GPU 支援
+(env_new) C:\Users\user\Automatic-Speech-Recognition-Speech-to-Text>python
+import torch
+print(f"CUDA available: {torch.cuda.is_available()}")
+if torch.cuda.is_available():
+    print(f"GPU: {torch.cuda.get_device_name(0)}")
+
+# Run the app
+python app.py

app.py

@@ -0,0 +1,966 @@
+import gradio as gr
+# from PIL import Image # Keep commented unless needed
+import torch
+from transformers import pipeline # Keep pipeline for standard models
+from transformers import AutoModelForSpeechSeq2Seq, AutoProcessor, AutoConfig, AutoModelForCausalLM
+import yt_dlp
+import tempfile
+import os
+import shutil
+import numpy as np
+import time # For timestamp formatting
+import soundfile as sf # For reading audio info
+import traceback # For printing full errors
+import platform
+import re
+import subprocess
+
+# --- 硬體檢查函數 ---
+def get_hardware_info():
+    """獲取 CPU 和 GPU 信息"""
+    # 獲取 CPU 信息
+    cpu_info = "Unknown CPU"
+    try:
+        if platform.system() == "Windows":
+            output = subprocess.check_output("wmic cpu get name", shell=True).decode().strip().split('\n')
+            if len(output) >= 2:
+                cpu_info = output[1].strip()
+        elif platform.system() == "Linux":
+            with open('/proc/cpuinfo', 'r') as f:
+                for line in f:
+                    if line.startswith('model name'):
+                        cpu_info = line.split(':')[1].strip()
+                        break
+        elif platform.system() == "Darwin":  # macOS
+            output = subprocess.check_output("sysctl -n machdep.cpu.brand_string", shell=True).decode().strip()
+            cpu_info = output
+    except Exception as e:
+        print(f"Error getting CPU info: {e}")
+
+    # 獲取 GPU 信息
+    gpu_info = None
+    if torch.cuda.is_available():
+        try:
+            gpu_info = torch.cuda.get_device_name(0)
+            # print(f"GPU detected: {gpu_info}")
+        except Exception as e:
+            print(f"Error getting GPU info: {e}")
+
+    # 保留 CPU 和 GPU 的完整名稱
+    # 不進行簡化，直接返回完整名稱
+
+    return cpu_info, gpu_info
+
+# --- Global Variables ---
+pipe = None
+phi4_model = None
+phi4_processor = None
+current_model_name = None
+current_device = "cpu"  # 默認使用 CPU
+
+# --- Model Data ---
+PHI4_MODEL_ID = "microsoft/Phi-4-multimodal-instruct"
+MERALION_MODEL_ID = "MERaLiON/MERaLiON-AudioLLM-Whisper-SEA-LION"
+SEALLM_MODEL_ID = "SeaLLMs/SeaLLMs-Audio-7B"
+
+MODEL_DATA = [
+    {"id": "openai/whisper-tiny", "params": "~39M", "size": "151 MB", "status_en": "Available", "status_zh": "可用", "type": "whisper"},
+    {"id": "openai/whisper-base", "params": "~74M", "size": "290 MB", "status_en": "Available", "status_zh": "可用", "type": "whisper"},
+    {"id": "openai/whisper-small", "params": "~244M", "size": "967 MB", "status_en": "Available", "status_zh": "可用", "type": "whisper"},
+    {"id": "openai/whisper-medium", "params": "~769M", "size": "3.06 GB", "status_en": "Available (CPU Slow)", "status_zh": "可用 (CPU 慢)", "type": "whisper"},
+    {"id": "openai/whisper-large", "params": "~1.55B", "size": "6.17 GB", "status_en": "Available (CPU Very Slow)", "status_zh": "可用 (CPU 極慢)", "type": "whisper"},
+    {"id": "openai/whisper-large-v2", "params": "~1.55B", "size": "6.17 GB", "status_en": "Available (CPU Very Slow)", "status_zh": "可用 (CPU 極慢)", "type": "whisper"},
+    {"id": "openai/whisper-large-v3", "params": "~1.55B", "size": "3.09 GB", "status_en": "Available (CPU Very Slow)", "status_zh": "可用 (CPU 極慢)", "type": "whisper"},
+    {"id": "openai/whisper-large-v3-turbo", "params": "~809M", "size": "1.62 GB", "status_en": "Available (Optimized, CPU Slow)", "status_zh": "可用 (優化, CPU 慢)", "type": "whisper"},
+    {"id": PHI4_MODEL_ID, "params": "~5.57B", "size": "11.15 GB", "status_en": "Multimodal (Need Trust, High RAM)", "status_zh": "多模態 (需信任,高RAM)", "type": "phi4"},
+    # {"id": MERALION_MODEL_ID, "params": "~9.93B", "size": "19.85 GB", "status_en": "Experimental (Need Trust, High RAM)", "status_zh": "實驗性 (需信任,高RAM)", "type": "other"},
+    # {"id": SEALLM_MODEL_ID, "params": "~8.29B", "size": "16.57 GB", "status_en": "Experimental (Need Trust, High RAM)", "status_zh": "實驗性 (需信任,高RAM)", "type": "other"},
+]
+MODEL_INFO_DICT = {m['id']: m for m in MODEL_DATA}
+MODEL_CHOICES_WITH_PARAMS = [
+    (f"{m['id'].split('/')[-1]} ({m['params']}, {m['size']}) - {m['status_en']} / {m['status_zh']}", m['id'])
+    for m in MODEL_DATA
+]
+DEFAULT_MODEL = "openai/whisper-tiny"
+
+# --- Language Data ---
+BILINGUAL_LANGUAGES_DICT = {
+    "auto": "Auto-detect / 自動偵測", "en": "English / 英文", "zh": "Chinese / 中文", "de": "German / 德文", "es": "Spanish / 西班牙文",
+    "ru": "Russian / 俄文", "ko": "Korean / 韓文", "fr": "French / 法文", "ja": "Japanese / 日文", "pt": "Portuguese / 葡萄牙文", "tr": "Turkish / 土耳其文",
+    "pl": "Polish / 波蘭文", "ca": "Catalan / 加泰隆尼亞文", "nl": "Dutch / 荷蘭文", "ar": "Arabic / 阿拉伯文", "sv": "Swedish / 瑞典文", "it": "Italian / 義大利文",
+    "id": "Indonesian / 印尼文", "hi": "Hindi / 印地文", "fi": "Finnish / 芬蘭文", "vi": "Vietnamese / 越南文", "he": "Hebrew / 希伯來文", "uk": "Ukrainian / 烏克蘭文",
+    "el": "Greek / 希臘文", "ms": "Malay / 馬來文", "cs": "Czech / 捷克文", "ro": "Romanian / 羅馬尼亞文", "da": "Danish / 丹麥文", "hu": "Hungarian / 匈牙利文",
+    "ta": "Tamil / 坦米爾文", "no": "Norwegian / 挪威文", "th": "Thai / 泰文", "ur": "Urdu / 烏爾都文", "hr": "Croatian / 克羅埃西亞文", "bg": "Bulgarian / 保加利亞文",
+    "lt": "Lithuanian / 立陶宛文", "la": "Latin / 拉丁文", "mi": "Maori / 毛利文", "ml": "Malayalam / 馬拉雅拉姆文", "cy": "Welsh / 威爾斯文", "sk": "Slovak / 斯洛伐克文",
+    "te": "Telugu / 泰盧固文", "fa": "Persian / 波斯文", "lv": "Latvian / 拉脫維亞文", "bn": "Bengali / 孟加拉文", "sr": "Serbian / 塞爾維亞文", "az": "Azerbaijani / 亞塞拜然文",
+    "sl": "Slovenian / 斯洛維尼亞文", "kn": "Kannada / 坎那達文", "et": "Estonian / 愛沙尼亞文", "mk": "Macedonian / 馬其頓文", "br": "Breton / 布列塔尼文",
+    "eu": "Basque / 巴斯克文", "is": "Icelandic / 冰島文", "hy": "Armenian / 亞美尼亞文", "ne": "Nepali / 尼泊爾文", "mn": "Mongolian / 蒙古文", "bs": "Bosnian / 波士尼亞文",
+    "kk": "Kazakh / 哈薩克文", "sq": "Albanian / 阿爾巴尼亞文", "sw": "Swahili / 史瓦希里文", "gl": "Galician / 加利西亞文", "mr": "Marathi / 馬拉地文", "pa": "Punjabi / 旁遮普文",
+    "si": "Sinhala / 僧伽羅文", "km": "Khmer / 高棉文", "sn": "Shona / 修納文", "yo": "Yoruba / 約魯巴文", "so": "Somali / 索馬利文", "af": "Afrikaans / 南非荷蘭文",
+    "oc": "Occitan / 奧克西坦文", "ka": "Georgian / 喬治亞文", "be": "Belarusian / 白俄羅斯文", "tg": "Tajik / 塔吉克文", "sd": "Sindhi / 信德文", "gu": "Gujarati / 古吉拉特文",
+    "am": "Amharic / 安哈拉文", "yi": "Yiddish / 意第緒文", "lo": "Lao / 寮文", "uz": "Uzbek / 烏茲別克文", "fo": "Faroese / 法羅文", "ht": "Haitian Creole / 海地克里奧爾文",
+    "ps": "Pashto / 普什圖文", "tk": "Turkmen / 土庫曼文", "nn": "Nynorsk / 新挪威文", "mt": "Maltese / 馬爾他文", "sa": "Sanskrit / 梵文", "lb": "Luxembourgish / 盧森堡文",
+    "my": "Myanmar / 緬甸文", "bo": "Tibetan / 藏文", "tl": "Tagalog / 他加祿文", "mg": "Malagasy / 馬達加斯加文", "as": "Assamese / 阿薩姆文", "tt": "Tatar / 韃靼文",
+    "haw": "Hawaiian / 夏威夷文", "ln": "Lingala / 林加拉文", "ha": "Hausa / 豪沙文", "ba": "Bashkir / 巴什基爾文", "jw": "Javanese / 爪哇文", "su": "Sundanese / 巽他文",
+    "yue": "Cantonese / 粵語",
+}
+WHISPER_LANGUAGES_LIST = []
+WHISPER_LANGUAGES_LIST.append((BILINGUAL_LANGUAGES_DICT["auto"], "auto"))
+def get_english_name(display_name_tuple): return display_name_tuple[0].split('/')[0].strip()
+sorted_languages = sorted( [(display_name, code) for code, display_name in BILINGUAL_LANGUAGES_DICT.items() if code != "auto"], key=get_english_name )
+WHISPER_LANGUAGES_LIST.extend(sorted_languages)
+PHI4_AUDIO_LANG_CODES = ["auto", "en", "zh", "de", "fr", "it", "ja", "es", "pt"]
+PHI4_LANGUAGES_LIST = [(BILINGUAL_LANGUAGES_DICT.get(code, code), code) for code in PHI4_AUDIO_LANG_CODES]
+
+# --- Microphone Prompt ---
+MIC_PROMPT = """**Try Reading / 試著朗讀:**
+"Success is stumbling from failure to failure with no loss of enthusiasm." - Winston Churchill
+「成功是在一次又一次失敗中，依然熱情不減地前行。」 - 溫斯頓・邱吉爾"""
+
+# --- YouTube Audio Download Function ---
+def download_youtube_audio(url):
+    # 使用固定的目錄來存儲下載的音訊文件，這樣它們就不會被刪除
+    download_dir = os.path.join(tempfile.gettempdir(), "youtube_downloads")
+    os.makedirs(download_dir, exist_ok=True)
+
+    # 從 URL 中提取視頻 ID 作為文件名的一部分
+    video_id = url.split("v=")[-1].split("&")[0] if "v=" in url else str(int(time.time()))
+    filename = f"youtube_{video_id}_{int(time.time())}"
+
+    temp_dir = tempfile.mkdtemp()
+    downloaded_path = None
+    try:
+        temp_filepath_tmpl = os.path.join(download_dir, f"{filename}.%(ext)s")
+        ydl_opts = {
+            'format': 'bestaudio/best',
+            'outtmpl': temp_filepath_tmpl,
+            'noplaylist': True,
+            'quiet': True,
+            'postprocessors': [{'key': 'FFmpegExtractAudio','preferredcodec': 'mp3','preferredquality': '192',}],
+            'ffmpeg_location': shutil.which("ffmpeg"),
+        }
+        if not ydl_opts['ffmpeg_location']: print("Warning: ffmpeg not found... / 警告：找不到 ffmpeg...")
+        with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+            info_dict = ydl.extract_info(url, download=True)
+            duration = info_dict.get('duration')
+            title = info_dict.get('title', 'unknown')
+
+            final_filepath = ydl.prepare_filename(info_dict)
+            if not final_filepath.endswith('.mp3'):
+                base_name = final_filepath.rsplit('.', 1)[0]
+                final_filepath = base_name + '.mp3'
+
+            if os.path.exists(final_filepath):
+                downloaded_path = final_filepath
+                print(f"YouTube audio downloaded: {downloaded_path}")
+                print(f"Title: {title}, Duration: {duration}s")
+            else:
+                potential_files = [os.path.join(download_dir, f) for f in os.listdir(download_dir) if f.startswith(filename) and f.endswith(".mp3")]
+                if potential_files:
+                    downloaded_path = potential_files[0]
+                    print(f"Warning: Could not find expected MP3, using fallback: {downloaded_path}")
+                    duration = None
+                else:
+                    raise FileNotFoundError(f"Audio file not found after download in {download_dir}")
+
+        return downloaded_path, temp_dir, duration
+    except Exception as e:
+        print(f"Error processing YouTube URL: {e}")
+        if temp_dir and os.path.exists(temp_dir):
+            try: shutil.rmtree(temp_dir)
+            except Exception as cleanup_e: print(f"Error cleaning temp directory {temp_dir}: {cleanup_e}")
+        return None, None, None
+
+# --- Timestamp Formatting ---
+def format_timestamp(seconds):
+    if seconds is None: return "N/A"
+    milliseconds = round(seconds * 1000)
+    seconds_int = int(milliseconds // 1000)
+    milliseconds_rem = milliseconds % 1000
+    minutes = seconds_int // 60
+    seconds_rem = seconds_int % 60
+    hours = minutes // 60
+    minutes_rem = minutes % 60
+    return f"{hours:01d}:{minutes_rem:02d}:{seconds_rem:02d}.{milliseconds_rem:03d}"
+
+# --- 下載功能 ---
+def update_download_file(filepath):
+    """當有音訊檔案時更新下載檔案"""
+    if filepath and os.path.exists(filepath):
+        return filepath
+    return None
+
+# --- YouTube 音訊處理 ---
+def process_youtube_url(youtube_url):
+    """處理 YouTube URL，下載音訊並返回播放器和下載按鈕的更新"""
+    if not youtube_url or not youtube_url.strip():
+        return gr.update(visible=False, value=None), gr.update(visible=False, value=None)
+
+    try:
+        print(f"Processing YouTube URL: {youtube_url}")
+        # 只使用我們需要的返回值
+        audio_path, _, _ = download_youtube_audio(youtube_url)
+
+        if audio_path and os.path.exists(audio_path):
+            # 返回音訊播放器和下載按鈕的更新
+            return gr.update(visible=True, value=audio_path), gr.update(visible=True, value=audio_path)
+        else:
+            return gr.update(visible=False, value=None), gr.update(visible=False, value=None)
+    except Exception as e:
+        print(f"Error processing YouTube URL: {e}")
+        return gr.update(visible=False, value=None), gr.update(visible=False, value=None)
+
+# --- Load ASR Pipeline ---
+def load_asr_pipeline(model_id):
+    global pipe, phi4_model, phi4_processor, current_device
+    print(f"DEBUG: Loading ASR pipeline for {model_id} on device: {current_device}")
+    trust_code = model_id in [MERALION_MODEL_ID, SEALLM_MODEL_ID]
+    if trust_code: print(f"DEBUG: Setting trust_remote_code=True for pipeline model {model_id}")
+    try:
+        phi4_model = None
+        phi4_processor = None
+
+        # 根據選擇的設備設置模型加載參數
+        if current_device == "gpu":
+            # 檢查 CUDA 是否可用
+            if torch.cuda.is_available():
+                try:
+                    # 嘗試直接使用 CUDA 設備
+                    pipe = pipeline(
+                        "automatic-speech-recognition",
+                        model=model_id,
+                        trust_remote_code=trust_code,
+                        device="cuda"
+                    )
+                    # 注意：第一次運行時可能會出現 attention mask 警告，這是正常的，不影響功能
+                    print(f"DEBUG: Using GPU (CUDA) for ASR pipeline. Available GPU: {torch.cuda.get_device_name(0)}")
+                except Exception as e:
+                    # 如果直接使用 CUDA 失敗，嘗試使用 device=0
+                    pipe = pipeline(
+                        "automatic-speech-recognition",
+                        model=model_id,
+                        trust_remote_code=trust_code,
+                        device=0
+                    )
+                    print(f"DEBUG: Using GPU (device=0) for ASR pipeline. Reason for device_map failure: {str(e)}")
+            else:
+                # 如果 CUDA 不可用，回退到 CPU 並警告用戶
+                pipe = pipeline(
+                    "automatic-speech-recognition",
+                    model=model_id,
+                    trust_remote_code=trust_code,
+                    device="cpu"
+                )
+                print("WARNING: GPU selected but CUDA is not available. Falling back to CPU.")
+        else:  # CPU
+            # 使用 CPU
+            pipe = pipeline(
+                "automatic-speech-recognition",
+                model=model_id,
+                trust_remote_code=trust_code,
+                device="cpu"
+            )
+            # 注意：第一次運行時可能會出現 attention mask 警告，這是正常的，不影響功能
+            print("DEBUG: Using CPU for ASR pipeline.")
+        print(f"DEBUG: Model loaded on device: {pipe.device}")
+        return pipe
+    except Exception as e:
+        print(f"Error loading ASR pipeline for {model_id}:")
+        traceback.print_exc()
+        raise e
+
+# --- Load Phi-4 Model ---
+def load_phi4_model(model_id):
+    global pipe, phi4_model, phi4_processor, current_device
+    print(f"DEBUG: Loading Phi-4 model {model_id} on device: {current_device}")
+    try:
+        pipe = None
+        phi4_processor = AutoProcessor.from_pretrained(model_id, trust_remote_code=True)
+
+        # 根據選擇的設備設置模型加載參數
+        if current_device == "gpu":
+            # 檢查 CUDA 是否可用
+            if torch.cuda.is_available():
+                try:
+                    # 嘗試直接使用 CUDA 設備
+                    phi4_model = AutoModelForCausalLM.from_pretrained(
+                        model_id,
+                        trust_remote_code=True,
+                        torch_dtype=torch.float16,  # 使用半精度以節省 GPU 記憶體
+                        _attn_implementation="eager",
+                    )
+                    phi4_model = phi4_model.to("cuda")
+                    print(f"DEBUG: Using GPU (CUDA) for Phi-4. Available GPU: {torch.cuda.get_device_name(0)}")
+                except Exception as e:
+                    # 如果直接使用 CUDA 失敗，嘗試使用 device=0
+                    try:
+                        phi4_model = AutoModelForCausalLM.from_pretrained(
+                            model_id,
+                            trust_remote_code=True,
+                            torch_dtype=torch.float16,
+                            _attn_implementation="eager",
+                        )
+                        phi4_model = phi4_model.to("cuda:0")
+                        print(f"DEBUG: Using GPU (device=0) for Phi-4. Reason for first attempt failure: {str(e)}")
+                    except Exception as e2:
+                        # 如果仍然失敗，回退到 CPU
+                        phi4_model = AutoModelForCausalLM.from_pretrained(
+                            model_id,
+                            trust_remote_code=True,
+                            torch_dtype=torch.float32,
+                            _attn_implementation="eager",
+                        )
+                        phi4_model = phi4_model.to("cpu")
+                        print(f"WARNING: Failed to use GPU for Phi-4, falling back to CPU. Error: {str(e2)}")
+            else:
+                # 如果 CUDA 不可用，回退到 CPU 並警告用戶
+                phi4_model = AutoModelForCausalLM.from_pretrained(
+                    model_id,
+                    trust_remote_code=True,
+                    torch_dtype=torch.float32,  # CPU 通常使用全精度
+                    _attn_implementation="eager",
+                )
+                phi4_model = phi4_model.to("cpu")
+                print("WARNING: GPU selected but CUDA is not available. Falling back to CPU for Phi-4.")
+        else:  # CPU
+            # 使用 CPU
+            phi4_model = AutoModelForCausalLM.from_pretrained(
+                model_id,
+                trust_remote_code=True,
+                torch_dtype=torch.float32,  # CPU 通常使用全精度
+                _attn_implementation="eager",
+            )
+            phi4_model = phi4_model.to("cpu")
+            print("DEBUG: Using CPU for Phi-4.")
+
+        print(f"DEBUG: Phi-4 model loaded on device: {next(phi4_model.parameters()).device}")
+        return phi4_model, phi4_processor
+    except Exception as e:
+        print(f"Error loading Phi-4 model {model_id}:")
+        traceback.print_exc()
+        if "scipy" in str(e) or "torchvision" in str(e) or "peft" in str(e):
+             missing_pkg = "scipy" if "scipy" in str(e) else "torchvision" if "torchvision" in str(e) else "peft"
+             raise type(e)(f"{e}. Please ensure '{missing_pkg}' is in requirements.txt") from e
+        else: raise e
+
+# --- Main Transcription Function ---
+def transcribe_audio(mic_input, file_input, youtube_url, selected_model_identifier,
+                     task, language, return_timestamps,
+                     phi4_prompt_text, device_choice,
+                     previous_output_text, active_tab):
+    global pipe, phi4_model, phi4_processor, current_model_name, current_device
+    audio_source = None
+    source_type_en = ""
+    source_type_zh = ""
+    temp_dir_to_clean = None
+    audio_duration = None
+    model_name_for_display = selected_model_identifier
+    model_load_time = 0.0
+    inference_time = 0.0
+    model_type = MODEL_INFO_DICT.get(selected_model_identifier, {}).get("type", "other")
+    output_text_accumulated = previous_output_text if previous_output_text else ""
+    status_update_prefix = output_text_accumulated + ("\n\n---\n\n" if output_text_accumulated else "")
+    final_output_text = output_text_accumulated
+
+    # 更新設備選���
+    if device_choice != current_device:
+        current_device = device_choice
+        print(f"DEBUG: Device changed to {current_device}")
+        # 設備變更時強制重新加載模型
+        pipe = None
+        phi4_model = None
+        phi4_processor = None
+        current_model_name = None
+
+    # --- Load Model ---
+    model_changed = selected_model_identifier != current_model_name
+    model_needs_load = (model_type == "phi4" and phi4_model is None) or (model_type != "phi4" and pipe is None)
+
+    if model_changed or model_needs_load:
+        warning_message = ""
+        # 移除未使用的 trust_code 變量
+        if selected_model_identifier in [PHI4_MODEL_ID, MERALION_MODEL_ID, SEALLM_MODEL_ID]:
+            warning_message += f"Warning: Model {selected_model_identifier} requires executing remote code.\n警告: 模型 {selected_model_identifier} 需要執行遠端程式碼。\n"
+        if "seallms" in selected_model_identifier.lower() or "meralion" in selected_model_identifier.lower(): warning_message += f"Warning: Model {selected_model_identifier} likely requires >16GB RAM.\n警告: 模型 {selected_model_identifier} 可能需要 >16GB RAM。\n"
+        if model_type == "phi4": warning_message += f"Warning: Phi-4 uses a different process.\n警告: Phi-4 使用不同處理流程。\n"
+        print(f"Attempting to load model / 嘗試載入模型: {selected_model_identifier} (Type / 類型: {model_type})")
+        status_update_str = warning_message + f"Loading model / 正在載入模型: {selected_model_identifier}..."
+        # 不使用 yield，而是更新 output_text_accumulated
+        output_text_accumulated = status_update_prefix + status_update_str
+
+        load_start_time = time.monotonic()
+        try:
+            if model_type == "phi4":
+                phi4_model, phi4_processor = load_phi4_model(selected_model_identifier)
+                pipe = None
+            else:
+                pipe = load_asr_pipeline(selected_model_identifier)
+                phi4_model = None
+                phi4_processor = None
+            load_end_time = time.monotonic()
+            model_load_time = load_end_time - load_start_time
+            current_model_name = selected_model_identifier
+            model_name_for_display = current_model_name
+            print(f"Model {current_model_name} loaded successfully ({model_load_time:.2f}s). / 模型 {current_model_name} 載入成功 ({model_load_time:.2f} 秒).")
+            status_update_str = warning_message + f"Model {current_model_name} loaded successfully / 載入成功 ({model_load_time:.2f}s)."
+            # 更新 output_text_accumulated
+            output_text_accumulated = status_update_prefix + status_update_str
+        except Exception as e:
+            load_end_time = time.monotonic()
+            model_load_time = load_end_time - load_start_time
+            print(f"Failed to load model {selected_model_identifier} ({model_load_time:.2f}s). / 載入模型 {selected_model_identifier} 失敗 ({model_load_time:.2f} 秒).")
+            error_msg = f"Error: Failed to load model {selected_model_identifier}:\n錯誤: 載入模型 {selected_model_identifier} 失敗:\n{e}\n({model_load_time:.2f}s)"
+            if "requires `accelerate`" in str(e): error_msg += "\n**Missing 'accelerate'. Please install. / 缺少 'accelerate'，請安裝.**"
+            if isinstance(e, (MemoryError, RuntimeError)) and "out of memory" in str(e).lower(): error_msg += "\n**Out of Memory. Try a smaller model. / 記憶體不足，請嘗試較小模型.**"
+            if "trust_remote_code=True" in str(e): error_msg += "\n**Requires trusting remote code. Model might be unsafe. / 需要信任遠端代碼，模型可能不安全.**"
+            if "scipy" in str(e) or "torchvision" in str(e) or "peft" in str(e):
+                 missing_pkg = "scipy" if "scipy" in str(e) else "torchvision" if "torchvision" in str(e) else "peft"
+                 error_msg += f"\n**Missing '{missing_pkg}'. Please install. / 缺少 '{missing_pkg}'，請安裝.**"
+            status_update_str = warning_message + error_msg
+            pipe = None
+            phi4_model = None
+            phi4_processor = None
+            current_model_name = None
+            # 更新 output_text_accumulated
+            output_text_accumulated = status_update_prefix + status_update_str
+            return (output_text_accumulated, gr.update(), gr.update(), gr.update()) # Keep inputs
+
+    # --- Check if model loaded ---
+    if (model_type == "phi4" and phi4_model is None) or (model_type != "phi4" and pipe is None):
+        output_text_accumulated = status_update_prefix + "Error: Cannot use model. / 錯誤: 無法使用模型."
+        return (output_text_accumulated, gr.update(), gr.update(), gr.update())
+
+    # --- Determine Input Source & Get Duration ---
+    # 根據當前活動的標籤選擇正確的輸入源
+    print(f"DEBUG: Active tab is {active_tab}")
+
+    if active_tab == "mic" and mic_input is not None:
+        audio_source = mic_input
+        source_type_en = "Microphone"
+        source_type_zh = "麥克風"
+    elif active_tab == "file" and file_input is not None:
+        # 處理 File 組件的輸出，它可能是一個文件路徑或一個包含文件路徑的列表
+        if isinstance(file_input, list) and len(file_input) > 0:
+            # 如果是列表，取第一個文件
+            audio_source = file_input[0]
+        else:
+            # 否則直接使用
+            audio_source = file_input
+        source_type_en = "File Upload"
+        source_type_zh = "檔案上傳"
+    elif active_tab == "youtube" and youtube_url and youtube_url.strip():
+        source_type_en = "YouTube"
+        source_type_zh = "YouTube"
+        status_update_str = f"Downloading YouTube Audio / 正在下載 YouTube 音訊..."
+        output_text_accumulated = status_update_prefix + status_update_str
+        audio_path, temp_dir, duration_yt = download_youtube_audio(youtube_url)
+        if audio_path:
+            audio_source = audio_path
+            temp_dir_to_clean = temp_dir
+            audio_duration = duration_yt
+        else:
+            output_text_accumulated = status_update_prefix + "Error: Failed to download YouTube audio. / 錯誤：無法下載 YouTube 音訊。"
+            return (output_text_accumulated, gr.update(), gr.update(), gr.update())
+    else:
+        # 如果沒有選擇任何輸入源或當前標籤沒有有效輸入
+        return (previous_output_text, gr.update(), gr.update(), gr.update())  # No input
+
+    if audio_source is None:
+       output_text_accumulated = status_update_prefix + f"Error: No audio file provided. / 錯誤：未提供音訊檔案."
+       return (output_text_accumulated, gr.update(), gr.update(), gr.update())
+
+    # 確保音頻文件存在
+    if not os.path.exists(audio_source):
+       output_text_accumulated = status_update_prefix + f"Error: Audio file not found '{audio_source}'. / 錯誤：找不到音訊檔案 '{audio_source}'."
+       return (output_text_accumulated, gr.update(), gr.update(), gr.update())
+
+    # 檢查文件是否為有效的音頻文件
+    valid_audio_extensions = ['.wav', '.mp3', '.ogg', '.flac', '.m4a', '.aac']
+    file_ext = os.path.splitext(audio_source)[1].lower()
+    if file_ext not in valid_audio_extensions:
+       output_text_accumulated = status_update_prefix + f"Error: Invalid audio file format '{file_ext}'. / 錯誤：無效的音訊檔案格式 '{file_ext}'."
+       return (output_text_accumulated, gr.update(), gr.update(), gr.update())
+
+    if audio_duration is None:
+        try:
+            # 根據文件格式選擇適當的方法獲取音頻時長
+            if file_ext == '.wav':
+                # 對於 WAV 文件，使用 wave 模塊
+                import wave
+                try:
+                    with wave.open(audio_source, 'rb') as wf:
+                        frames = wf.getnframes()
+                        rate = wf.getframerate()
+                        audio_duration = frames / float(rate)
+                        print(f"Got audio duration from wave module / 從 wave 模塊獲取音檔時長: {audio_duration:.2f}s")
+                except Exception as wave_err:
+                    print(f"Could not get audio duration from wave module / 無法從 wave 模塊獲取音檔時長: {wave_err}")
+                    # 如果 wave 模塊失敗，嘗試使用 soundfile
+                    info = sf.info(audio_source)
+                    audio_duration = info.duration
+                    print(f"Got audio duration from soundfile / 從 soundfile 獲取音檔時長: {audio_duration:.2f}s")
+            else:
+                # 對於其他格式，使用 soundfile
+                info = sf.info(audio_source)
+                audio_duration = info.duration
+                print(f"Got audio duration from soundfile / 從 soundfile 獲取音檔時長: {audio_duration:.2f}s")
+        except Exception as e:
+            print(f"Could not get audio duration / 無法獲取音檔時長: {e}")
+            # 如果無法獲取時長，設置一個默認值
+            audio_duration = 0.0
+            print(f"Using default audio duration / 使用默認音檔時長: {audio_duration:.2f}s")
+
+    print(f"Processing with {current_model_name} from [{source_type_en} / {source_type_zh}]: {audio_source}")
+    print(f"Options: Task='{task}', Language(Source)='{language}', Timestamps='{return_timestamps}'")
+    if model_type == "phi4": print(f"Phi-4 Prompt: '{phi4_prompt_text}'")
+
+    status_update_str = f"Processing, please wait... / 正在處理，請稍候...\n(Model / 模型: {model_name_for_display})"
+    output_text_accumulated = status_update_prefix + status_update_str
+
+    # --- Execute & Timing ---
+    inference_start_time = time.monotonic()
+    current_run_output = ""
+    timing_info_str = ""
+    try:
+        if model_type == "phi4":
+            print("DEBUG: Processing with Phi-4...")
+            if not phi4_model or not phi4_processor: raise ValueError("Phi-4 model/processor not loaded / Phi-4 模型/處理器未載入")
+            if not phi4_prompt_text: raise ValueError("Phi-4 requires a prompt text / Phi-4 需要提示文字")
+            user_prompt_tag='<|user|>'
+            assistant_prompt_tag='<|assistant|>'
+            end_tag='<|end|>'
+            prompt = f"{user_prompt_tag}<|audio_1|>{phi4_prompt_text}{end_tag}{assistant_prompt_tag}"
+            audio_data, samplerate = sf.read(audio_source)
+            inputs = phi4_processor(text=prompt, audios=[(audio_data, samplerate)], return_tensors='pt').to(phi4_model.device)
+            with torch.no_grad(): generate_ids = phi4_model.generate(**inputs, max_new_tokens=500, num_logits_to_keep=0) # Added num_logits_to_keep=0
+            generate_ids = generate_ids[:, inputs['input_ids'].shape[1]:]
+            result_text = phi4_processor.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=False)[0]
+            current_run_output = result_text.strip()
+            return_timestamps = False
+        else: # Whisper or other pipeline models
+            print("DEBUG: Processing with ASR pipeline...")
+            if not pipe: raise ValueError("ASR pipeline not loaded / ASR pipeline 未載入")
+            generate_kwargs_pipe = {"task": task}
+
+            # 根據任務處理語言參數
+            if task == "transcribe":
+                # 在轉錄任務中，language 表示源語言
+                if language != "auto":
+                    generate_kwargs_pipe["language"] = language
+                    print(f"DEBUG: Setting source language to {language} for transcription")
+            else:  # translate
+                # 在翻譯任務中，Whisper 只支持翻譯為英文，所以我們忽略 language 參數
+                # 但我們仍然可以在日誌中記錄目標語言
+                print(f"DEBUG: Translation target language is {language}, but Whisper only supports English as target")
+
+            # 設置 pipeline 參數
+            pipeline_kwargs = {
+                "chunk_length_s": 30,
+                "batch_size": 1,
+                "return_timestamps": "chunks" if return_timestamps else False,
+                "generate_kwargs": generate_kwargs_pipe
+            }
+
+            # 使用 pipeline 調用處理音訊
+            # 注意：第一次運行時可能會出現 attention mask 警告，這是正常的，不影響功能
+            # 第二次及後續運行不會出現警告，且處理速度會更快
+            result = pipe(audio_source, **pipeline_kwargs)
+
+            print("DEBUG: pipe() call finished.")
+            print("DEBUG: Raw result type:", type(result))
+            print("DEBUG: Raw result content:", result)
+
+            # 處理不同格式的結果
+            if return_timestamps and isinstance(result, dict) and "chunks" in result:
+                formatted_chunks = [f"[{format_timestamp(chunk.get('timestamp', (None,))[0])} -> {format_timestamp(chunk.get('timestamp', (None, None))[1])}] {chunk.get('text', '').strip()}" for chunk in result["chunks"]]
+                current_run_output = "\n".join(formatted_chunks).strip()
+            elif isinstance(result, dict) and "text" in result:
+                current_run_output = result["text"].strip()
+            elif isinstance(result, str):
+                current_run_output = result.strip()
+            elif isinstance(result, list) and len(result) > 0 and isinstance(result[0], dict) and 'generated_text' in result[0]:
+                current_run_output = result[0]['generated_text'].strip()
+            else:
+                current_run_output = f"(Unrecognized result format / 無法識別的結果格式: {type(result)})"
+
+            print("DEBUG: Processed result:", current_run_output[:100] + "..." if len(current_run_output) > 100 else current_run_output)
+
+        inference_end_time = time.monotonic()
+        inference_time = inference_end_time - inference_start_time
+        if not current_run_output: current_run_output = "(Audio empty or unrecognizable / 音檔空白或無法辨識)"
+
+        # --- Format Timing Info (Plain Text, EN / ZH) ---
+        timing_info_str = f"Model / 模型: {model_name_for_display}\n"
+        if model_load_time > 0: timing_info_str += f"Model Load Time / 模型載入時間: {model_load_time:.2f} seconds / 秒\n"
+        timing_info_str += f"Inference Time / 推論時間: {inference_time:.2f} seconds / 秒\n"
+        relative_speed_str = "(relative time unavailable / 無法計算相對時間)"
+        if audio_duration is not None and audio_duration > 0:
+            relative_speed = inference_time / audio_duration
+            # Corrected format for relative speed
+            relative_speed_str = f"audio duration / 音檔長度 x {relative_speed:.2f}"
+            timing_info_str += f"audio duration / 音檔時長: {audio_duration:.2f} seconds / 秒\n"
+        timing_info_str += f"relative speed / 相對速度: {relative_speed_str}" # Corrected format
+
+        print(f"Processing finished. / 處理完成。")
+        print(timing_info_str.replace('\n', ' | '))
+        print(f"Result Text / 結果文字:\n{current_run_output}") # Print result text
+
+        # 確保 current_run_output 不為空
+        if not current_run_output or current_run_output.strip() == "":
+            current_run_output = "No text detected in audio / 音頻中未檢測到文字"
+
+        # 構建最終輸出文本，確保包含所有必要信息
+        final_output_text = ""
+        if status_update_prefix and status_update_prefix.strip():
+            final_output_text += status_update_prefix + "\n"
+
+        # 添加模型和時間信息
+        final_output_text += timing_info_str + "\n\n"
+
+        # 添加結果文本，並確保它被正確標記
+        final_output_text += "Result Text / 結果文字:\n" + current_run_output
+
+        # 確保最終輸出不是空的或只有一個點
+        final_output_text = final_output_text.strip()
+        if final_output_text == "." or not final_output_text:
+            final_output_text = timing_info_str + "\n\nResult Text / 結果文字:\n" + current_run_output
+
+        # 返回完整的文本結果，包括模型信息和處理時間
+        # 確保返回的是有效的文本，而不是單個點
+        if final_output_text == ".":
+            print("DEBUG: Detected dot-only output, fixing...")
+            # 構建更有意義的輸出
+            fixed_output = f"{timing_info_str}\n\nResult Text / 結果文字:\n{current_run_output}"
+            return fixed_output
+        return final_output_text
+
+    except Exception as e:
+        inference_end_time = time.monotonic()
+        inference_time = inference_end_time - inference_start_time
+        print(f"DEBUG: Exception occurred during processing / 處理過程中發生錯誤:")
+        traceback.print_exc()
+        error_message = f"Processing Failed / 處理失敗:\n{e}"
+        final_output_text = (status_update_prefix + error_message).strip()
+        timing_info_str = f"Model / 模型: {model_name_for_display}\n"
+        if model_load_time > 0: timing_info_str += f"Model Load Time / 模型載入時間: {model_load_time:.2f} seconds / 秒\n"
+        timing_info_str += f"Inference Time (until error) / 推論時間 (至錯誤): {inference_time:.2f} seconds / 秒\n"
+        timing_info_str += "Processing Failed / 處理失敗"
+        final_output_text += "\n\n" + timing_info_str
+        if isinstance(e, (MemoryError, RuntimeError)) and "out of memory" in str(e).lower(): final_output_text += "\n\nOut of Memory, try smaller model. / 記憶體不足，請用小模型."
+
+    finally:
+        if temp_dir_to_clean:
+            print(f"Cleaning YouTube temp files / 清理 YouTube 暫存: {temp_dir_to_clean}")
+            # Corrected finally block syntax
+            try:
+                shutil.rmtree(temp_dir_to_clean)
+            except Exception as e:
+                print(f"Failed to clean temp files / 清理暫存失敗: {e}")
+
+    print("DEBUG: Returning final result tuple...")
+    # Return final tuple: Update output_text, KEEP inputs by using gr.update()
+    # 如果 final_output_text 是字典（ASR pipeline 的輸出），直接返回它
+    # 否則，返回標準的元組格式
+    if isinstance(final_output_text, dict):
+        return final_output_text
+    else:
+        return (final_output_text, gr.update(), gr.update(), gr.update())
+
+
+# --- UI Update Functions ---
+# 添加一個函數來更新音頻播放器
+def update_file_audio_player(file_path):
+    if file_path is None:
+        return gr.update(value=None, visible=False)
+
+    # 如果是列表，取第一個文件
+    if isinstance(file_path, list) and len(file_path) > 0:
+        file_path = file_path[0]
+
+    # 檢查文件是否存在
+    if not os.path.exists(file_path):
+        return gr.update(value=None, visible=False)
+
+    # 檢查是否為有效的音頻文件
+    valid_audio_extensions = ['.wav', '.mp3', '.ogg', '.flac', '.m4a', '.aac']
+    file_ext = os.path.splitext(file_path)[1].lower()
+    if file_ext not in valid_audio_extensions:
+        return gr.update(value=None, visible=False)
+
+    # 返回更新的音頻播放器
+    return gr.update(value=file_path, visible=True)
+
+def update_task_choices(selected_model_id):
+    model_type = MODEL_INFO_DICT.get(selected_model_id, {}).get("type", "other")
+    if model_type == "whisper": new_choices = [ ("Transcribe / 轉錄", "transcribe"), ("Translate (Whisper only to English) / 翻譯 (Whisper 僅支援轉譯至英文)", "translate") ]
+    else: new_choices = [ ("Transcribe / 轉錄", "transcribe"), ("Translate / 轉譯", "translate") ]
+    return gr.update(choices=new_choices)
+
+def update_phi4_prompt_ui(selected_model_id, task, language_code):
+    model_type = MODEL_INFO_DICT.get(selected_model_id, {}).get("type", "other")
+    is_phi4 = model_type == "phi4"
+    prompt_text = ""
+    if is_phi4:
+        if task == "transcribe":
+            if language_code == "auto":
+                prompt_text = "Transcribe the audio to text."
+            else:
+                lang_display_name = BILINGUAL_LANGUAGES_DICT.get(language_code, language_code)
+                lang_english_name = lang_display_name.split('/')[0].strip()
+                prompt_text = f"Transcribe the audio in {lang_english_name}."
+        elif task == "translate":
+            # 在翻譯任務中，language_code 表示目標語言
+            lang_display_name = BILINGUAL_LANGUAGES_DICT.get(language_code, language_code)
+            lang_english_name = lang_display_name.split('/')[0].strip()
+            if language_code == "auto" or language_code == "en":
+                # 如果目標語言是自動或英文，默認翻譯為英文
+                prompt_text = "Translate the audio to text."
+            else:
+                # 如果指定了目標語言，翻譯為該語言
+                prompt_text = f"Detect the language in the audio and translate it to {lang_english_name}."
+    # Return update for Textbox visibility and value directly
+    return gr.update(visible=is_phi4, value=prompt_text)
+
+def update_language_choices(selected_model_id):
+    model_type = MODEL_INFO_DICT.get(selected_model_id, {}).get("type", "other")
+    if model_type == "phi4": return gr.update(choices=PHI4_LANGUAGES_LIST, value="auto")
+    else: return gr.update(choices=WHISPER_LANGUAGES_LIST, value="auto")
+
+def update_timestamp_visibility(selected_model_id):
+    model_type = MODEL_INFO_DICT.get(selected_model_id, {}).get("type", "other")
+    print(f"DEBUG: Updating timestamp visibility for {selected_model_id}. Type: {model_type}. Visible: {model_type != 'phi4'}") # Debug print
+    return gr.update(visible=(model_type != "phi4"))
+
+def update_language_ui(model_id, task):
+    """根據模型和任務更新語言選擇器的標籤和可見性"""
+    model_type = MODEL_INFO_DICT.get(model_id, {}).get("type", "other")
+
+    # 如果是 Whisper 模型且任務是翻譯，則隱藏語言選擇器（因為 Whisper 只能翻譯成英文）
+    if model_type == "whisper" and task == "translate":
+        return gr.update(visible=False, label="Target Language / 目標語言")
+
+    # 否則，根據任務更新標籤並顯示
+    if task == "transcribe":
+        return gr.update(visible=True, label="Source Language / 來源語言")
+    else:  # translate
+        return gr.update(visible=True, label="Target Language / 目標語言")
+
+# --- Gradio Interface ---
+# Preserving user's CSS choices
+compact_css = """
+.tabitem { margin: 0rem !important; padding: 0rem !important;}
+.compact-file > div { min-height: unset !important; }
+"""
+
+# 移除 JavaScript 代碼，改用純 CSS 解決方案
+
+with gr.Blocks(css=compact_css, theme=gr.themes.Default(spacing_size=gr.themes.sizes.spacing_sm, text_size=gr.themes.sizes.text_sm)) as demo:
+    # 只顯示標題，不顯示 GPU 狀態
+    gr.Markdown("# Automatic Speech Recognition(ASR) & Speech to Text(STT) / 語音辨識、語音轉文字 🔊🔄📝\nUse AI models to transcribe or translate speech from microphone, file uploads, or YouTube. / 使用 AI 模型轉錄或翻譯來自麥克風、上傳檔案或 YouTube 的語音。")
+
+    with gr.Row():
+        # Left Column: Input & Options
+        with gr.Column(scale=4): # Preserving user's scale
+            # 添加一個隱藏的狀態變量來跟踪當前活動的標籤
+            active_tab = gr.State(value="mic")  # 默認為麥克風標籤
+
+            # 定義標籤切換函數
+            def set_active_tab(tab_name):
+                return tab_name
+
+            with gr.Tabs() as tabs:
+                with gr.TabItem("🎤 Microphone / 麥克風") as mic_tab:
+                    gr.Markdown(MIC_PROMPT, elem_classes="compact-markdown")
+                    mic_input = gr.Audio(sources=["microphone"], type="filepath", label="Record Audio / 錄製音訊")
+                    download_output = gr.File(label="Download Recording / 下載錄音檔", interactive=False, elem_classes="compact-file")
+
+                with gr.TabItem("📁 Upload File / 上傳檔案") as file_tab:
+                    # 使用 File 組件代替 Audio 組件，避免音頻處理問題
+                    file_input = gr.File(label="Upload Audio File / 上傳音訊檔", file_types=["audio"], type="filepath")
+
+                    # 添加音頻播放器
+                    file_audio_player = gr.Audio(label="Audio Preview / 音訊預覽", interactive=False, visible=False)
+
+                with gr.TabItem("▶️ YouTube") as youtube_tab:
+                    youtube_input = gr.Textbox(label="YouTube URL / 網址", placeholder="Paste YouTube link here / 在此貼上 YouTube 連結")
+                    gr.Examples(examples=[["https://www.youtube.com/watch?v=5D7l0tqQJ7k"]], inputs=[youtube_input], label="Example YouTube URL / 範例 YouTube 網址")
+
+                    # 添加 YouTube 音訊播放器和下載按鈕
+                    with gr.Row():
+                        youtube_audio_player = gr.Audio(label="YouTube Audio / YouTube 音訊", interactive=False, visible=False)
+                    youtube_download = gr.File(label="Download YouTube Audio / 下載 YouTube 音訊", interactive=False, visible=False, elem_classes="compact-file")
+
+                # 添加標籤切換事件
+                mic_tab.select(fn=lambda: set_active_tab("mic"), inputs=[], outputs=[active_tab])
+                file_tab.select(fn=lambda: set_active_tab("file"), inputs=[], outputs=[active_tab])
+                youtube_tab.select(fn=lambda: set_active_tab("youtube"), inputs=[], outputs=[active_tab])
+
+            # Options in a single column with ID for spacing
+            with gr.Column(elem_id="options-block"): # elem_id for CSS targeting if needed
+                model_select = gr.Dropdown(choices=MODEL_CHOICES_WITH_PARAMS, label="Model / 模型", value=DEFAULT_MODEL, elem_classes="compact-label")
+                # 獲取硬體信息並顯示具體的 CPU 和 GPU 型號
+                cpu_info, gpu_info = get_hardware_info()
+                device_choices = [(f"CPU ({cpu_info})", "cpu")]
+                if torch.cuda.is_available() and gpu_info:
+                    device_choices.append((f"GPU ({gpu_info})", "gpu"))
+                device_input = gr.Radio(choices=device_choices, label="Device / 設備", value="cpu", elem_classes="compact-label radio-align")
+                task_input = gr.Radio(choices=[("Transcribe / 轉錄", "transcribe"), ("Translate / 轉譯", "translate")], label="Task / 任務", value="transcribe", elem_classes="compact-label radio-align")
+                language_input = gr.Dropdown(choices=WHISPER_LANGUAGES_LIST, label="Source Language / 來源語言", value="auto", elem_classes="compact-label")
+                # Phi-4 prompt directly in the column, no Accordion
+                phi4_prompt_input = gr.Textbox(label="Only for Phi-4 Prompt / 僅用於 Phi-4 指令", placeholder="e.g., Transcribe the audio to text.", lines=1, visible=False, elem_classes="compact-label") # Preserving user label and params
+                timestamp_input = gr.Checkbox(label="Show Timestamps / 顯示時間戳", value=False, elem_classes="compact-label checkbox-align") # Preserving user label
+
+        # Right Column: Output
+        with gr.Column(scale=6): # Preserving user's scale
+            submit_button = gr.Button("Submit / 提交", variant="primary") # Preserving user's text and placement
+            output_text = gr.Textbox(
+                label="Result / 結果",
+                lines=25,  # 設置顯示的行數
+                max_lines=25,  # 設置最大行數，超過會顯示滾動條
+                interactive=True,
+                placeholder="Results appear here (new results appended). / 結果將顯示在此 (新結果會附加在後面)",
+                elem_classes="result-textbox",  # 保留 CSS 類
+                autoscroll=False  # 不自動滾動到底部，讓用戶可以控制滾動
+            )
+
+    # --- Event Listeners ---
+    model_select.change(fn=update_language_choices, inputs=model_select, outputs=language_input)
+    model_select.change(fn=update_task_choices, inputs=[model_select], outputs=[task_input])
+    # Link prompt update function correctly
+    model_select.change(fn=update_phi4_prompt_ui, inputs=[model_select, task_input, language_input], outputs=[phi4_prompt_input])
+    task_input.change(fn=update_phi4_prompt_ui, inputs=[model_select, task_input, language_input], outputs=[phi4_prompt_input])
+    language_input.change(fn=update_phi4_prompt_ui, inputs=[model_select, task_input, language_input], outputs=[phi4_prompt_input])
+
+    # 根據模型和任務更新語言選擇器
+    task_input.change(fn=update_language_ui, inputs=[model_select, task_input], outputs=language_input)
+    model_select.change(fn=update_language_ui, inputs=[model_select, task_input], outputs=language_input)
+    # Link timestamp visibility function
+    model_select.change(fn=update_timestamp_visibility, inputs=model_select, outputs=timestamp_input)
+
+    # 連接下載按鈕功能
+    mic_input.change(fn=update_download_file, inputs=mic_input, outputs=download_output)
+
+    # 連接文件上傳音頻播放器
+    file_input.change(fn=update_file_audio_player, inputs=file_input, outputs=file_audio_player)
+
+    # 連接 YouTube 處理功能
+    youtube_input.change(
+        fn=process_youtube_url,
+        inputs=youtube_input,
+        outputs=[youtube_audio_player, youtube_download],
+        show_progress=True
+    )
+
+    # 添加一個函數來直接調用 transcribe_audio，不使用 yield
+    def transcribe_audio_with_error_handling(*args):
+        try:
+            # 獲取模型信息
+            selected_model_identifier = args[3]  # 第四個參數是 selected_model_identifier
+            model_name_for_display = selected_model_identifier
+
+            # 獲取音頻時長，用於估算處理時間
+            audio_source = None
+            active_tab = args[-1]  # 最後一個參數是 active_tab
+
+            if active_tab == "mic" and args[0] is not None:
+                audio_source = args[0]
+            elif active_tab == "file" and args[1] is not None:
+                if isinstance(args[1], list) and len(args[1]) > 0:
+                    audio_source = args[1][0]
+                else:
+                    audio_source = args[1]
+            elif active_tab == "youtube" and args[2] and args[2].strip():
+                # YouTube 處理較複雜，暫不估算時間
+                pass
+
+            # 檢查音頻文件是否存在
+            if audio_source and os.path.exists(audio_source):
+                print(f"Processing audio file: {audio_source}")
+
+            # 清除之前的輸出，確保結果顯示正確
+            print("\n" + "="*50)
+            print("NEW TRANSCRIPTION PROCESS STARTED")
+            print("="*50 + "\n")
+
+            # 開始計時
+            start_time = time.time()
+
+            # 直接調用 transcribe_audio 函數
+            result = transcribe_audio(*args)
+
+            # 處理完成
+            elapsed_time = time.time() - start_time
+
+            # 處理結果（現在應該是文本字符串）
+            print("DEBUG: Result type:", type(result))
+            print("DEBUG: Final result:", result)
+
+            # 檢查結果是否為字符串
+            if isinstance(result, str):
+                if result.strip() == ".":
+                    # 如果結果只是一個點 "."，這是一個已知問題
+                    print("DEBUG: Detected dot-only output in handler, fixing...")
+
+                    # 從控制台輸出中提取最後一個處理結果
+                    # 這是一個臨時解決方案
+                    model_info = f"Model / 模型: {model_name_for_display}"
+                    inference_time_info = f"Processing Time / 處理時間: {elapsed_time:.2f} seconds / 秒"
+
+                    # 嘗試從控制台日誌中提取結果文本
+                    # 這裡我們假設結果已經在控制台中打印出來了
+                    final_text = f"{model_info}\n{inference_time_info}\n\nResult Text / 結果文字:\n"
+                    final_text += "(Please check console for complete transcription / 請查看控制台獲取完整轉錄)"
+
+                    print("DEBUG: Created replacement result:", final_text[:100] + "..." if len(final_text) > 100 else final_text)
+                else:
+                    # 正常結果，直接使用
+                    final_text = result
+                    print("DEBUG: Using original result text")
+            else:
+                # 如果結果不是字符串，創建一個新的結果字符串
+                final_text = f"Model / 模型: {model_name_for_display}\n"
+                final_text += f"Processing Time / 處理時間: {elapsed_time:.2f} seconds / 秒\n\n"
+                final_text += "(No text detected in audio / 音頻中未檢測到文字)"
+                print("DEBUG: Created new result for non-string:", final_text[:100] + "..." if len(final_text) > 100 else final_text)
+
+            return final_text, gr.update(), gr.update(), gr.update()
+        except Exception as e:
+            import traceback
+            error_msg = f"Error during processing: {str(e)}\n\n{traceback.format_exc()}"
+            print(error_msg)
+
+            # 返回錯誤訊息，保持其他輸出不變
+            return f"處理過程中發生錯誤 / Error during processing:\n{str(e)}", gr.update(), gr.update(), gr.update()
+
+    # Main submit action - Corrected outputs list
+    submit_button.click(
+        fn=transcribe_audio_with_error_handling,
+        inputs=[mic_input, file_input, youtube_input, model_select, task_input, language_input, timestamp_input, phi4_prompt_input, device_input, output_text, active_tab],
+        outputs=[output_text, mic_input, file_input, youtube_input], # 保持原始輸出
+        show_progress="full" # 顯示完整進度條
+    )
+
+
+
+# --- Launch App ---
+if __name__ == "__main__":
+    # 獲取硬體信息
+    cpu_info, gpu_info = get_hardware_info()
+    has_gpu = gpu_info is not None
+
+    print(f"CPU: {cpu_info}")
+    if has_gpu:
+        print(f"GPU: {gpu_info}")
+    else:
+        print("No GPU detected")
+
+    # REMEMBER: Update requirements.txt with accelerate, scipy, torchvision, peft
+    demo.launch(
+        debug=True,
+        max_threads=4,  # 減少最大線程數，提高穩定性
+        show_error=True,  # 顯示錯誤詳情
+        server_name="127.0.0.1",  # 本地運行
+        server_port=7860,  # 指定端口
+        quiet=False,  # 顯示所有日誌
+        prevent_thread_lock=True  # 防止線程鎖定
+    )

assets/audio.wav

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

assets/sample_audio.mp3

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

pyproject.toml

@@ -0,0 +1,11 @@
+[tool.pyright]
+include = ["app.py"]
+exclude = ["**/node_modules", "**/__pycache__", "**/env", "**/env_new", "**/envsource"]
+reportMissingImports = false
+reportGeneralTypeIssues = false
+reportOptionalMemberAccess = false
+reportOptionalSubscript = false
+reportOptionalCall = false
+reportOptionalIterable = false
+reportOptionalContextManager = false
+reportOptionalOperand = false

pyrightconfig.json

@@ -0,0 +1,5 @@
+{
+  "venvPath": ".",
+  "venv": "env",
+  "reportMissingImports": false
+}

requirements.txt

@@ -0,0 +1,22 @@
+# Main packages for Hugging Face Spaces
+gradio>=5.0.0
+transformers>=4.30.0
+huggingface-hub>=0.15.0
+torch>=2.0.0
+torchvision>=0.15.0
+torchaudio>=2.0.0
+
+# Acceleration and optimization
+accelerate>=1.0.0
+safetensors>=0.3.0
+
+# Audio processing
+yt-dlp>=2023.0.0
+soundfile>=0.12.0
+pydub>=0.25.0
+
+# Data processing
+numpy>=2.0.0
+scipy>=1.0.0      # Needed by Phi-4
+peft>=0.5.0       # Needed by Phi-4
+backoff>=2.0.0    # Needed by Phi-4

requirements_local.txt

@@ -0,0 +1,30 @@
+# Main packages
+gradio>=5.0.0
+transformers>=4.30.0
+huggingface-hub>=0.15.0
+
+# PyTorch with CUDA support - these will be installed from the specified URL
+--extra-index-url https://download.pytorch.org/whl/cu126
+torch==2.7.0+cu126
+torchvision==0.22.0+cu126
+torchaudio==2.7.0+cu126
+
+# Acceleration and optimization
+accelerate>=1.0.0
+safetensors>=0.3.0
+
+# Audio processing
+yt-dlp>=2023.0.0
+soundfile>=0.12.0
+pydub>=0.25.0
+
+# Data processing
+numpy>=2.0.0
+scipy>=1.0.0      # Needed by Phi-4
+peft>=0.5.0       # Needed by Phi-4
+backoff>=2.0.0    # Needed by Phi-4
+
+# Important dependencies that might need specific versions
+typing_extensions>=4.10.0
+filelock>=3.0.0
+fsspec>=2024.0.0