# -*- coding: utf-8 -*- """ 日本語・中国語・インドネシア語・英語の音声翻訳(Windows 10 以降) 音声認識 : faster-whisper(CTranslate2 実装。small / large-v3-turbo / large-v3) 翻訳 : NLLB-200(CTranslate2 形式。1.3B を int8 に量子化したもの、または 3.3B の float16 版) 音声合成 : Windows SAPI5(OneCore 音声を含む。pywin32)、 Windows に音声が無い言語は sherpa-onnx の音声合成を別プロセスで実行 入力 : マイク(16 kHz モノラル、暗騒音に適応する発話区間検出)または音声ファイル 画面は 3 つのタブで構成する。 「実行」 : 翻訳方向・モデル・実行デバイスの選択、スライダーによる実行時パラメータの変更、 認識結果と訳文の表示、入力レベル計。スライダーの変更は次の発話の処理から反映される。 「処理過程」: 発話ごとの算出過程。区間検出の判定値、言語識別の事後確率、認識された区間ごとの 非発話確率と圧縮率、棄却判定の各項目、文分割と翻訳の入出力、処理時間を保持する。 「ヘルプ」 : 操作手順、使用モデルとライブラリ、主要パラメータ、入力と前処理、処理手順、 評価方法と指標、再現の条件、限界と不確実性、ライセンス。 推論はすべてこの PC 上で行い、音声とテキストを外部へ送信しない。通信はモデルの初回取得のみ。 モデルは models、ログは logs、設定は settings.json に保存する。保存先は実行のたびにこのファイル (実行ファイル化した場合は実行ファイル)の場所から求めるため、移動しても常にその隣に作られる。 内蔵の音声合成は別プロセスで実行する。sherpa-onnx は onnxruntime.dll を同梱しており、 faster-whisper が使う onnxruntime(Silero VAD)と同じプロセスに読み込むと、先に読み込まれた版の DLL が共用されて版の不一致で失敗することがあるため。 マイク入力は音声合成の再生中も破棄しない。スピーカーから回り込んだ合成音声は、認識結果と 直前に合成した文との文字列類似度(difflib)で判定して破棄する。 実行ファイルの作成(PyInstaller 6 以降、--onefile): pyinstaller --onefile --clean --noconfirm --windowed --name SpeechTranslator ^ --collect-data faster_whisper --collect-binaries ctranslate2 ^ --collect-binaries onnxruntime --collect-all sherpa_onnx transcribe.py --collect-data faster_whisper は Silero VAD のモデル(faster_whisper/assets)を、--collect-all sherpa_onnx は内蔵音声合成の DLL(sherpa_onnx/lib)を同梱するために必要である。GPU で実行する PC には CUDA 12 用の cuBLAS と cuDNN を導入して PATH を通すか、環境変数 CUDA_PATH の bin に 置く。pip の nvidia-cublas-cu12 と nvidia-cudnn-cu12 を同梱する場合は --collect-binaries nvidia.cublas --collect-binaries nvidia.cudnn を加える。 """ import collections import ctypes import difflib import fnmatch import gc import importlib.metadata import importlib.util import json import multiprocessing import os import queue import re import site import sys import tarfile import threading import time import urllib.request import winreg from datetime import datetime, timedelta from pathlib import Path # ---------------------------------------------------------------- 保存先(このファイルの場所が基準) FROZEN = getattr(sys, "frozen", False) # PyInstaller で実行ファイル化して実行しているか # 実行ファイル化した場合、__file__ は一時展開先を指し、終了時に削除されるとモデルを取得し直す # ことになるため、実行ファイルの場所を基準にする。 APP_DIR = Path(sys.executable if FROZEN else __file__).resolve().parent MODEL_DIR = APP_DIR / "models" ASR_ROOT = MODEL_DIR / "asr" TTS_DIR = MODEL_DIR / "tts" HF_CACHE = MODEL_DIR / "_hf_cache" LOG_DIR = APP_DIR / "logs" SETTINGS_PATH = APP_DIR / "settings.json" for _d in (MODEL_DIR, ASR_ROOT, HF_CACHE): _d.mkdir(parents=True, exist_ok=True) os.environ["HF_HOME"] = str(HF_CACHE) os.environ.setdefault("HF_HUB_DISABLE_SYMLINKS_WARNING", "1") os.environ.setdefault("HF_HUB_DISABLE_TELEMETRY", "1") os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1") # 進捗は画面の進捗バーに示す # --windowed で作った実行ファイルでは標準出力・標準エラー出力が None になり、ライブラリが書き込むと # 例外になるため、書き込みを捨てる出力先を割り当てる(内蔵音声合成の子プロセスでも同じ)。 for _name in ("stdout", "stderr"): if getattr(sys, _name) is None: setattr(sys, _name, open(os.devnull, "w", encoding="utf-8")) # ---------------------------------------------------------------- DLL の検索先 def add_dll_dir(folder): """folder の DLL を、既存の検索先より先に探させる。 Python の拡張モジュールの読み込みは os.add_dll_directory の登録先を、ライブラリ内部の LoadLibrary(cuDNN が下位ライブラリを読み込む場合など)は環境変数 PATH を検索するため、 両方に加える。 """ os.add_dll_directory(str(folder)) os.environ["PATH"] = str(folder) + os.pathsep + os.environ.get("PATH", "") def register_cuda_dll_dirs(): """CTranslate2 が GPU 実行で読み込む cuBLAS・cuDNN の DLL を見つけられるようにする。 検索先は、pip の nvidia-cublas-cu12・nvidia-cudnn-cu12 が置くフォルダ (site-packages/nvidia/*/bin。実行ファイル化して同梱した場合は展開先の nvidia/*/bin)と、 CUDA Toolkit の bin(環境変数 CUDA_PATH)。 """ roots = [Path(sys._MEIPASS)] if FROZEN else [ Path(p) for p in site.getsitepackages() + [site.getusersitepackages()]] folders = [f for root in roots for f in sorted((root / "nvidia").glob("*/bin"))] if os.environ.get("CUDA_PATH"): folders.append(Path(os.environ["CUDA_PATH"]) / "bin") for folder in reversed(folders): # 先頭のフォルダほど先に探されるよう、逆順に加える if folder.is_dir(): add_dll_dir(folder) register_cuda_dll_dirs() # ctranslate2 を読み込む前に行う import tkinter as tk import tkinter.font as tkfont from tkinter import ttk, filedialog import ctranslate2 import numpy as np import pythoncom import sounddevice as sd import win32com.client from tokenizers import Tokenizer # ---------------------------------------------------------------- 音響・信号処理の定数 SAMPLE_RATE = 16000 BLOCK_SIZE = 1600 # 0.1 秒 BLOCK_SEC = BLOCK_SIZE / SAMPLE_RATE BAND_LOW_HZ = 200.0 BAND_HIGH_HZ = 3800.0 HPF_CUTOFF_HZ = 80.0 NOISE_WINDOW_SEC = 4.0 NOISE_PERCENTILE = 25.0 NOISE_FLOOR_DBFS = -75.0 # 暗騒音推定値の下限 NOISE_RISE_DB_PER_SEC = 12.0 # 暗騒音推定値の上昇速度の上限(下降には即時に追従する) CALIB_SEC = 1.0 # 開始直後に暗騒音を測定する時間 CALIB_PERCENTILE = 50.0 VOICED_MIN_SEC = 2.0 ABS_RELEASE_MARGIN_DB = 6.0 # 発話開始は SN 比で判定する。絶対レベルの下限は無音入力への誤反応を防ぐ最小限に留め、 # 雑音による誤検出は認識後の判定(VAD による発話長・非発話確率・定型句)で破棄する。 NOISE_PROFILES = { "quiet": dict(onset_snr_db=6.0, release_snr_db=3.0, onset_blocks=3, silence_sec=0.7, pre_roll_sec=0.4, abs_onset_dbfs=-68.0), "noisy": dict(onset_snr_db=12.0, release_snr_db=6.0, onset_blocks=4, silence_sec=0.9, pre_roll_sec=0.5, abs_onset_dbfs=-58.0), } DEFAULT_NOISE_PROFILE = "quiet" MIN_UTTERANCE_SEC = 0.35 SOFT_SPLIT_SEC = 7.0 # この長さを超えた発話は息継ぎ(短い無音)で区切る SOFT_PAUSE_SEC = 0.3 # 息継ぎとみなす無音の長さ HARD_MAX_SEC = 12.0 # 息継ぎが無くても区切る長さ(表示までの待ち時間の上限を抑える) SPLIT_LOOKBACK_SEC = 3.0 # 上限で区切る際、直近のこの範囲で最もレベルの低い位置を区切りにする TARGET_DBFS = -24.0 # 認識に与える音声の目標実効値(0 dBFS は実効値 1.0) PEAK_CEIL = 0.95 MAX_GAIN_DB = 30.0 LOW_MIC_GAIN_DB = 18.0 CLIP_PEAK = 0.99 # 標本ピーク値がフルスケールのこの割合以上ならクリッピングの可能性がある CLIP_HOLD_SEC = 1.0 # 入力レベル計で、クリッピングの可能性を赤で示し続ける時間 METER_MIN_DB = -70.0 METER_MAX_DB = 0.0 METER_MS = 60 METER_RELEASE_DB_PER_SEC = 60.0 MIN_SPEECH_SEC = 0.25 # 認識された区間(Silero VAD で非発話部分を除いた後)の合計長の下限 LOW_SPEECH_RATIO = 0.2 # 区間全体に対する発話部分の割合の下限 SHORT_TEXT_CHARS = 4 SHORT_TEXT_NO_SPEECH_MAX = 0.3 IDLE_NOTICE_SEC = 20.0 # 発話が検出されない状態が続いたら経過秒数を表示する DUP_WINDOW_SEC = 8.0 DUP_MIN_CHARS = 4 # 短い相槌は重複判定の対象にしない # マイクが拾った自分の合成音声の判定(ヘッドセットかスピーカーかの設定を不要にする) SELF_ECHO_WINDOW_SEC = 12.0 SELF_ECHO_RATIO = 0.82 # 通常の類似度しきい値 SELF_ECHO_LOOSE_RATIO = 0.45 # 区間の大半が合成音声の再生と重なっていた場合のしきい値 SELF_ECHO_OVERLAP = 0.6 # 区間のうち合成音声を再生していたブロックの割合 SELF_ECHO_MIN_CHARS = 4 SELF_ECHO_CONTAIN_CHARS = 6 SPOKEN_HISTORY = 16 # ---------------------------------------------------------------- モデルの定数 CPU_THREADS = max(2, min(8, os.cpu_count() or 4)) def gpu_status(): """GPU で実行できるかを返す(認識・翻訳とも CTranslate2 で実行する)。 "ok" : CUDA 対応 GPU があり、CUDA 12 用の cuBLAS と cuDNN(9。ctranslate2 4.4 以前は 8)を 読み込める "nolib": CUDA 対応 GPU はあるが、cuBLAS または cuDNN を読み込めない "nogpu": CUDA 対応 GPU が無い 読み込めない状態で GPU を選ぶとモデルの読み込みで失敗するため、事前に確かめて選択肢から外す。 ここでの try は演算の失敗を隠すためのものではなく、DLL を読み込めるかという事実の判定である。 """ if ctranslate2.get_cuda_device_count() == 0: return "nogpu" def loadable(name): try: ctypes.WinDLL(name, winmode=0) # winmode=0 : PATH を含む標準の検索順で探す return True except OSError: return False found = loadable("cublas64_12.dll") and (loadable("cudnn64_9.dll") or loadable("cudnn64_8.dll")) return "ok" if found else "nolib" # 認識モデル : キー -> (保存フォルダ名, Hugging Face のリポジトリ) # large-v3-turbo は openai/whisper-large-v3-turbo を faster-whisper 用に変換したもの。 ASR_SPECS = { "standard": ("small", "Systran/faster-whisper-small"), "high": ("large-v3-turbo", "mobiuslabsgmbh/faster-whisper-large-v3-turbo"), "max": ("large-v3", "Systran/faster-whisper-large-v3"), } MODEL_TEXT_KEY = {"standard": "model_std", "high": "model_high", "max": "model_max"} MODEL_KEYS = tuple(MODEL_TEXT_KEY) ASR_PATTERNS = ("config.json", "preprocessor_config.json", "model.bin", "tokenizer.json", "vocabulary.*") HEAVY_MODELS = ("high", "max") # CPU では処理時間が長いことを案内するモデル # 翻訳モデル : キー -> (保存フォルダ名, Hugging Face のリポジトリ)。保存先は MODEL_DIR の直下。 # standard : NLLB-200 distilled 1.3B を int8 で保存した版(約 1.4 GB)。CPU では保存時の int8 の # まま、GPU では読み込み時に float16 へ変換して実行する(CTranslate2 は読み込み時の # 型変換に対応する)。 # large : NLLB-200 3.3B を float16 で保存した第三者による変換版(約 6.7 GB)。GPU では # float16 のまま実行し、CPU では読み込み時に int8 へ変換する。 MT_SPECS = { "standard": ("nllb-200-distilled-1.3B-ct2-int8", "OpenNMT/nllb-200-distilled-1.3B-ct2-int8"), "large": ("nllb-200-3.3B-ct2-float16", "entai2965/nllb-200-3.3B-ctranslate2-float16"), } MT_TEXT_KEY = {"standard": "mt_std", "large": "mt_large"} MT_PATTERNS = ("config.json", "model.bin", "shared_vocabulary.json", "tokenizer.json") MT_TOKENIZER_FILE = "tokenizer.json" EOS_TOKEN = "" READY_MARK = ".download-complete" # 取得完了の印。存在すれば以後は通信せずに起動する # 内蔵の音声合成(sherpa-onnx)のモデル。sherpa-onnx の公式リリースから取得する。 # supertonic : Supertonic 3(ja / id / en に使う。話者 0 を用いる) # piper_zh : Piper の標準中国語音声 xiao_ya(Supertonic 3 は中国語に対応していないため) TTS_RELEASE_URL = "https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/{}.tar.bz2" BUILTIN_TTS_MODELS = { "supertonic": dict(name="sherpa-onnx-supertonic-3-tts-int8-2026-05-11", label="Supertonic 3", size="129 MB"), "piper_zh": dict(name="vits-piper-zh_CN-xiao_ya-medium", label="Piper xiao_ya", size="60 MB"), } BUILTIN_MODEL_FOR_LANG = {"ja": "supertonic", "id": "supertonic", "en": "supertonic", "zh": "piper_zh"} BUILTIN_SPEAKER_ID = 0 BUILTIN_FLOW_STEPS = 8 # Supertonic の復号ステップ数(sherpa-onnx の用例の値) BUILTIN_THREADS = 2 # 認識・翻訳の処理を妨げないよう少なめにする BUILTIN_PEAK = 0.9 # 再生時の標本ピークの目標値(Windows の音声と音量をそろえる) BUILTIN_MAX_GAIN = 4.0 BUILTIN_CHUNK_SEC = 0.05 # 再生を中断できる間隔 BUILTIN_LOAD_TIMEOUT_SEC = 180.0 # 計算型は、装置が対応するもののうち先頭の候補を使う(float32 は常に対応している)。 COMPUTE_PREFERENCE = { "cuda": ("float16", "int8_float16", "float32"), "cpu": ("int8", "int8_float32", "float32"), } # 認識のビーム幅。faster-whisper の transcribe の既定値は 5。 DECODE_MODES = {"fast": 2, "accurate": 5} DECODE_TEXT_KEY = {"fast": "decode_fast", "accurate": "decode_acc"} DECODE_KEYS = tuple(DECODE_TEXT_KEY) MT_BEAM_DEFAULT = {"cpu": 2, "cuda": 4} # 翻訳時に繰り返しを禁止する n-gram の長さ(トークン数): 目的言語の種類 -> 長さ。 # 3 トークンでは「one of the …, one of the …」のように 1 文の中で正当に繰り返される句も # 生成できなくなるため、空白で語を区切る言語は 4 とする。日本語・中国語はトークンが 1〜数文字と # 短く、助詞(の・に・を、的 など)や短い語句が正当に繰り返されるため 6 とし、同じ断片が # 続けて出る型の暴走だけを抑える。既出トークンへの減点(repetition_penalty)は、機能語のように # 正当に繰り返されるトークンの確率も下げるため用いない。 MT_NO_REPEAT_NGRAM = {"spaced": 4, "cjk": 6} MT_MAX_DECODING = 256 FILE_BATCH_SIZE = 8 # 一括推論は音声ファイルの処理にのみ使う VAD_PARAMS = { "threshold": 0.35, "min_speech_duration_ms": 100, "min_silence_duration_ms": 250, "speech_pad_ms": 250, } ASR_NO_SPEECH_MAX = 0.6 ASR_COMPRESSION_MAX = 2.4 # 同じ語句を繰り返す型のハルシネーションを抑える ASR_TEMPERATURES = (0.0, 0.2, 0.4) # 圧縮率がしきい値を超えたときの再復号に用いる温度 # トークン当たり平均対数確率による棄却は行わない。正規の発話でもしきい値を下回ることがあり、 # 棄却すると何も表示されないという原因の分かりにくい失敗になるため。 # 認識では n-gram の繰り返し禁止と既出トークンへの減点を用いない(faster-whisper の既定値のまま)。 # 正当に繰り返される語句の確率まで下げるためで、繰り返しの暴走は圧縮率による再復号と棄却で除く。 LANGS = ("ja", "id", "en", "zh") DISPLAY_ORDER = ("en", "ja", "id", "zh") NLLB_CODE = {"ja": "jpn_Jpan", "id": "ind_Latn", "en": "eng_Latn", "zh": "zho_Hans"} NO_SPACE_LANGS = ("ja", "zh") def by_lang(*texts): """表示言語の順(英・日・尼・中)に並べた文字列から辞書を作る。""" return dict(zip(DISPLAY_ORDER, texts)) LANG_NAMES = { "ja": by_lang("Japanese", "日本語", "Bahasa Jepang", "日语"), "id": by_lang("Indonesian", "インドネシア語", "Bahasa Indonesia", "印尼语"), "en": by_lang("English", "英語", "Bahasa Inggris", "英语"), "zh": by_lang("Chinese", "中国語", "Bahasa Mandarin", "中文"), } CONV_WORD = by_lang("Conversation", "会話", "Percakapan", "对话") AUTO_WORD = by_lang("language auto-detected", "言語を自動判定", "deteksi bahasa otomatis", "自动识别语种") ASR_ONLY_WORD = by_lang("Transcribe only (no translation)", "文字起こしのみ(翻訳しない)", "Transkripsi saja (tanpa terjemahan)", "仅转写(不翻译)") # 公開されている重みファイルのサイズとパラメータ数(画面での案内に使う) MODEL_FACTS = { "standard": dict(params=by_lang("244 M", "2.44 億", "244 juta", "2.44 亿"), size="483 MB"), "high": dict(params=by_lang("809 M", "8.09 億", "809 juta", "8.09 亿"), size="1.62 GB"), "max": dict(params=by_lang("1.55 B", "15.5 億", "1,55 miliar", "15.5 亿"), size="3.09 GB"), } MT_FACTS = { "standard": dict(params=by_lang("1.3 B", "13 億", "1,3 miliar", "13 亿"), size="1.4 GB"), "large": dict(params=by_lang("3.3 B", "33 億", "3,3 miliar", "33 亿"), size="6.7 GB"), } SEP = " / " Direction = collections.namedtuple("Direction", "label a b mode") Part = collections.namedtuple("Part", "start end text no_speech compression") Utterance = collections.namedtuple( "Utterance", "audio tts_ratio reason start end blocks active") Recognition = collections.namedtuple( "Recognition", "parts lang posterior probs duration rerun") Translation = collections.namedtuple("Translation", "text rows") # 発話区間を確定した理由(処理過程タブに表示する) SPLIT_REASON = { "silence": "継続判定が無音となり、しきい値の時間(無音とみなす継続時間)続いた", "pause": "発話が 7 秒を超え、継続判定が短時間途切れた時点で区切った" "(息継ぎの無音による場合と、暗騒音の推定値の上昇による場合がある)", "limit": "最大発話長に達し、直近で最もレベルの低い位置で区切った", "finish": "入力の終了で区切った", } def join_unique(parts): """重複を除き、出現順を保って併記する。""" return SEP.join(dict.fromkeys(parts)) def display_langs(a, b): """画面の併記に使う言語(英語と、選択中の 2 言語)。""" return list(dict.fromkeys(("en", a, b))) def _fixed_label(s, d): return join_unique(f"{LANG_NAMES[s][x]} → {LANG_NAMES[d][x]}" for x in display_langs(s, d)) def _conv_label(a, b): return join_unique(f"{CONV_WORD[x]}: {LANG_NAMES[a][x]} ⇔ {LANG_NAMES[b][x]} ({AUTO_WORD[x]})" for x in display_langs(a, b)) DIRECTIONS = [Direction(_fixed_label(s, d), s, d, "fixed") for s in LANGS for d in LANGS if s != d] N_FIXED = len(DIRECTIONS) DIRECTIONS += [Direction(_conv_label(a, b), a, b, "conv") for i, a in enumerate(LANGS) for b in LANGS[i + 1:]] DIRECTIONS += [Direction(join_unique(f"{ASR_ONLY_WORD[x]} ({AUTO_WORD[x]})" for x in DISPLAY_ORDER), None, None, "asr")] DIRECTION_BY_LABEL = {d.label: d for d in DIRECTIONS} # 選択は表示ラベルで解決する DEFAULT_DIRECTION = next(d for d in DIRECTIONS if (d.mode, d.a, d.b) == ("fixed", "id", "ja")) # ---------------------------------------------------------------- 実行時パラメータ(スライダー) class Params: """画面のスライダーで変更できる実行時パラメータ。 UI スレッドが書き換え、区間検出・正規化・推論・音声合成の各スレッドが読む。値の読み書きは 単一の属性代入なので、ロックを用いない(読み手は常に、書き換え前か書き換え後のどちらかの値を 得る)。変更は次のブロック(区間検出)、次の発話(正規化)、次の復号(ビーム幅)、次の文 (読み上げ速度)から反映される。 """ def __init__(self): self.gain_target_db = TARGET_DBFS self.onset_snr_db = NOISE_PROFILES[DEFAULT_NOISE_PROFILE]["onset_snr_db"] self.silence_sec = NOISE_PROFILES[DEFAULT_NOISE_PROFILE]["silence_sec"] self.max_utter_sec = HARD_MAX_SEC self.asr_beam = DECODE_MODES["fast"] self.mt_beam = MT_BEAM_DEFAULT["cpu"] self.tts_rate = 0 # SAPI5 の Rate(−10〜+10) @property def gain_target(self): """正規化の目標実効値(0 dBFS を 1.0 とする振幅)。""" return 10.0 ** (self.gain_target_db / 20.0) def apply_profile(self, profile): """使用環境の推奨値に、しきい値と無音時間を戻す。""" p = NOISE_PROFILES[profile] self.onset_snr_db = p["onset_snr_db"] self.silence_sec = p["silence_sec"] def as_dict(self): return dict(gain_target_db=self.gain_target_db, onset_snr_db=self.onset_snr_db, silence_sec=self.silence_sec, max_utter_sec=self.max_utter_sec, asr_beam=self.asr_beam, mt_beam=self.mt_beam, tts_rate=self.tts_rate) def restore(self, data): """保存された値を、取り得る範囲に収めて復元する。""" if not isinstance(data, dict): return pick = lambda key, low, high, cast: (cast(data[key]) if isinstance(data.get(key), (int, float)) else None) for key, low, high, attr in (("gain_target_db", -40.0, -14.0, "gain_target_db"), ("onset_snr_db", 3.0, 18.0, "onset_snr_db"), ("silence_sec", 0.3, 1.5, "silence_sec"), ("max_utter_sec", 5.0, 20.0, "max_utter_sec"), ("asr_beam", 1, 10, "asr_beam"), ("mt_beam", 1, 8, "mt_beam"), ("tts_rate", -10, 10, "tts_rate")): value = pick(key, low, high, float) if value is not None: setattr(self, attr, min(max(value, low), high)) self.asr_beam, self.mt_beam, self.tts_rate = (int(round(self.asr_beam)), int(round(self.mt_beam)), int(round(self.tts_rate))) # ---------------------------------------------------------------- 信号処理 _WINDOW = np.hanning(BLOCK_SIZE).astype(np.float64) _FREQS = np.fft.rfftfreq(BLOCK_SIZE, 1.0 / SAMPLE_RATE) _EDGE = np.ones(_FREQS.size) _EDGE[[0, -1]] = 0.5 # パーセバルの定理に基づき、窓の電力で正規化した片側パワースペクトルの帯域内和を平均電力とする _BAND_WEIGHT = (2.0 * _EDGE * ((_FREQS >= BAND_LOW_HZ) & (_FREQS <= BAND_HIGH_HZ)) / (BLOCK_SIZE ** 2 * float(np.mean(_WINDOW ** 2)))) def band_rms(block): """ハン窓を掛けた FFT から推定する、200–3800 Hz 帯域内の実効値(RMS)。""" power = np.abs(np.fft.rfft(block * _WINDOW)) ** 2 return float(np.sqrt(max(float(np.dot(power, _BAND_WEIGHT)), 0.0))) def to_db(value): return 20.0 * np.log10(max(float(value), 1e-9)) def highpass(x): """零位相の高域通過フィルタ。振幅応答は |H(f)| = f²/(f²+fc²) で、遮断周波数 fc では 1/2 (−6 dB)、fc より低い領域では 12 dB/oct で減衰する。空調音などの低周波成分を減衰させる。""" freqs = np.fft.rfftfreq(x.size, 1.0 / SAMPLE_RATE) resp = freqs ** 2 / (freqs ** 2 + HPF_CUTOFF_HZ ** 2) return np.fft.irfft(np.fft.rfft(x) * resp, x.size).astype(np.float32) def normalize(x, target_rms): """直流成分を除いて高域通過した後、実効値が目標値に近づく利得を掛ける。 利得は標本ピークが PEAK_CEIL を超えない範囲かつ MAX_GAIN_DB 以下とし、減衰はさせない。 戻り値は (整形後の音声, 利得 [dB], 整形前の標本ピーク値)。 """ raw_peak = float(np.max(np.abs(x))) if x.size else 0.0 x = highpass(x - float(np.mean(x))) rms = float(np.sqrt(np.mean(x ** 2))) peak = float(np.max(np.abs(x))) if rms <= 0.0 or peak <= 0.0: return x, 0.0, raw_peak gain = max(min(target_rms / rms, PEAK_CEIL / peak, 10.0 ** (MAX_GAIN_DB / 20.0)), 1.0) return (x * gain).astype(np.float32), 20.0 * np.log10(gain), raw_peak # ---------------------------------------------------------------- 発話区間検出器 class Segmenter: """SN 比と絶対レベルによる発話区間検出器。 ここでの SN 比は、ブロックの帯域内実効値と暗騒音推定値との比を dB で表したもの(発話中の値には 暗騒音の成分も含まれる)。 しきい値(発話開始の SN 比)、無音とみなす継続時間、最大発話長は Params から毎ブロック読む ため、動作中に変更すると次のブロックから反映される。発話開始に要する連続ブロック数、先行して 保持する長さ、絶対レベルの下限は使用環境(quiet / noisy)で決まる。 SOFT_SPLIT_SEC を超えた発話は、息継ぎ(短い無音)の時点で区切る。息継ぎが無いまま最大発話長に 達した場合は、直近 SPLIT_LOOKBACK_SEC の範囲で最もレベルの低いブロックの直後で区切り、それ 以降の音声は次の区間の先頭に回す(話し続けても表示が遅れすぎないようにする)。 無音でなかったブロックが onset_blocks 個に満たない区間は、無音として出力しない。 各区間について、音声合成を再生していたブロックの割合も返す(自己音声の判定に使う)。 棄却した区間は理由別に数え、処理過程タブの集計に示す。 """ def __init__(self, profile, params): self.p = params self.profile = profile p = NOISE_PROFILES[profile] self.onset_blocks = p["onset_blocks"] self.abs_onset_dbfs = p["abs_onset_dbfs"] self.abs_release_dbfs = p["abs_onset_dbfs"] - ABS_RELEASE_MARGIN_DB self.release_gap_db = p["onset_snr_db"] - p["release_snr_db"] self.noise_floor = 10.0 ** (NOISE_FLOOR_DBFS / 20.0) self.noise_hist = collections.deque(maxlen=max(4, int(NOISE_WINDOW_SEC / BLOCK_SEC))) self.voiced_mins = collections.deque(maxlen=max(4, int(VOICED_MIN_SEC / BLOCK_SEC))) self.pre_roll = collections.deque(maxlen=max(1, int(p["pre_roll_sec"] / BLOCK_SEC))) self.buf = [] # [(ブロック, 合成音声を再生中だったか, 無音でなかったか, 実効値, 時刻)] self.voiced = False self.onset_run = 0 self.silence_run = 0 self.noise = self.noise_floor self.level = 0.0 self.calib_left = max(1, int(CALIB_SEC / BLOCK_SEC)) self.calib_samples = [] self.soft_blocks = max(1, int(SOFT_SPLIT_SEC / BLOCK_SEC)) self.soft_pause_blocks = max(1, int(SOFT_PAUSE_SEC / BLOCK_SEC)) self.lookback_blocks = max(1, int(SPLIT_LOOKBACK_SEC / BLOCK_SEC)) self.rise_step = 10.0 ** (NOISE_RISE_DB_PER_SEC * BLOCK_SEC / 20.0) self.dropped = collections.Counter() # 棄却した区間の理由別の件数 @property def calibrating(self): return self.calib_left > 0 @property def release_snr_db(self): """発話の継続を判定する SN 比。発話開始のしきい値より低く、1.5 dB を下回らない。""" return max(1.5, self.p.onset_snr_db - self.release_gap_db) def silence_blocks(self): return max(1, int(round(self.p.silence_sec / BLOCK_SEC))) def max_blocks(self): return max(2, int(round(self.p.max_utter_sec / BLOCK_SEC))) def onset_threshold_db(self): return max(to_db(self.noise) + self.p.onset_snr_db, self.abs_onset_dbfs) def push(self, block, tts_active, stamp=None): """1 ブロック(0.1 秒)を投入し、発話区間が確定したら Utterance を返す。""" stamp = time.monotonic() if stamp is None else stamp rms = band_rms(block) self.level = rms level_db = to_db(rms) if self.calib_left > 0: self.calib_left -= 1 self.calib_samples.append(rms) self.pre_roll.append((block, bool(tts_active), False, rms, stamp)) if self.calib_left == 0: self.noise = max(float(np.percentile(self.calib_samples, CALIB_PERCENTILE)), self.noise_floor) self.noise_hist.extend([self.noise] * self.noise_hist.maxlen) return None self._track_noise(rms) snr = level_db - to_db(self.noise) # 各ブロックが、その時点の暗騒音推定値に対して無音でなかった(発話継続の判定で無音と # みなされない)かも記録する active = snr >= self.release_snr_db and level_db >= self.abs_release_dbfs item = (block, bool(tts_active), active, rms, stamp) if self.voiced: return self._push_voiced(item, snr, level_db) self.pre_roll.append(item) if snr >= self.p.onset_snr_db and level_db >= self.abs_onset_dbfs: self.onset_run += 1 if self.onset_run >= self.onset_blocks: self.voiced = True self.onset_run = self.silence_run = 0 self.voiced_mins.clear() self.buf = list(self.pre_roll) else: self.onset_run = 0 return None def _track_noise(self, rms): """暗騒音レベルの推定。下降には即時に追従し、上昇は NOISE_RISE_DB_PER_SEC に制限する。 発話中は、直近 VOICED_MIN_SEC の最小値に向けてのみ上昇させる。""" if self.voiced: self.voiced_mins.append(rms) if len(self.voiced_mins) == self.voiced_mins.maxlen: target = min(self.voiced_mins) if target > self.noise: self.noise = min(target, self.noise * self.rise_step) self.noise_hist.append(self.noise) else: self.noise_hist.append(rms) target = float(np.percentile(self.noise_hist, NOISE_PERCENTILE)) self.noise = min(target, self.noise * self.rise_step) if target > self.noise else target self.noise = max(self.noise, self.noise_floor) def _push_voiced(self, item, snr, level_db): self.buf.append(item) self.pre_roll.append(item) quiet = snr < self.release_snr_db or level_db < self.abs_release_dbfs self.silence_run = self.silence_run + 1 if quiet else 0 if self.silence_run >= self.silence_blocks(): self.voiced = False return self._flush("silence") # 長い発話は息継ぎで区切る。発話は継続中として扱い、直前の区間(pre_roll)を # 次の区間の先頭に含めて語の途中での切断を補う。 if len(self.buf) >= self.soft_blocks and self.silence_run >= self.soft_pause_blocks: out = self._flush("pause") self.buf = list(self.pre_roll) return out # 息継ぎが無いまま上限に達した場合は、直近で最もレベルの低い位置(語と語の間である # 可能性が高い)で区切り、残りを次の区間の先頭にする。 if len(self.buf) >= self.max_blocks(): return self._split_at_quietest() return None def _split_at_quietest(self): start = max(1, len(self.buf) - self.lookback_blocks) cut = start + int(np.argmin([item[3] for item in self.buf[start:]])) + 1 rest = self.buf[cut:] self.buf = self.buf[:cut] out = self._flush("limit") self.buf = rest return out def _flush(self, reason): buf, self.buf, self.silence_run = self.buf, [], 0 if not buf: return None audio = np.concatenate([item[0] for item in buf]) if audio.size < MIN_UTTERANCE_SEC * SAMPLE_RATE: self.dropped["short"] += 1 return None if to_db(float(np.sqrt(np.mean(audio ** 2)))) < self.abs_release_dbfs: self.dropped["quiet"] += 1 return None # 無音でなかったブロックが、発話開始の判定に要するブロック数に満たない区間は出力しない。 # 息継ぎで区切った直後に話し終えた場合、残りの区間はほぼ無音になり、これを認識させると # Whisper が「ありがとうございました」のような定型句を生成することがあるため。 active = sum(item[2] for item in buf) if active < self.onset_blocks: self.dropped["inactive"] += 1 return None return Utterance(audio, sum(item[1] for item in buf) / len(buf), reason, buf[0][4], buf[-1][4], len(buf), active) def finish(self): self.voiced = False return self._flush("finish") # ---------------------------------------------------------------- 認識結果の検査 # 無音・雑音区間で Whisper が出力しやすいことが知られる定型句(動画字幕に由来する表現) HALLUCINATION_PHRASES = ( "ご視聴ありがとうございました", "ご覧いただきありがとうございました", "チャンネル登録", "最後までご視聴", "字幕作成者", "Terima kasih telah menonton", "Terima kasih sudah menonton", "Subtitle by", "Sub by", "Subtitles by", "amara.org", "amara org", "Thanks for watching", "Thank you for watching", "Transcript Emily Beynon", "请不吝点赞", "订阅本频道", "字幕由", "谢谢观看", "感谢观看", "明镜与点点栏目", ) # 無音・雑音区間で生成されやすい謝辞のみの出力(compare_key で正規化した形)。 # 会話では正規の発話でもあるため、非発話確率が高い場合に限って破棄する(short_noise を参照)。 THANKS_ONLY_KEYS = frozenset(( "ありがとうございました", "ありがとうございます", "どうもありがとうございました", "terimakasih", "terimakasihbanyak", "thankyou", "thanks", "thankyouverymuch", "谢谢", "谢谢大家", )) _KANA_RANGES = ((0x3040, 0x309F), (0x30A0, 0x30FF), (0xFF66, 0xFF9D)) _HAN_RANGES = ((0x3400, 0x4DBF), (0x4E00, 0x9FFF), (0xF900, 0xFAFF)) def _in_ranges(ch, ranges): return any(low <= ord(ch) <= high for low, high in ranges) def script_kind(text): """文字体系の種類を返す。'kana'(仮名を含む)/ 'han'(漢字を含む)/ 'latin' / None(判定不能)。""" letters = [c for c in text if c.isalnum()] if len(letters) < 2: return None if any(_in_ranges(c, _KANA_RANGES) for c in letters): return "kana" if any(_in_ranges(c, _HAN_RANGES) for c in letters): return "han" if any(c.isascii() and c.isalpha() for c in letters): return "latin" return None def script_conflicts(text, lang): """認識結果の文字体系がその言語の表記と矛盾するかを判定する。判定不能な場合は矛盾なしとする。""" kind = script_kind(text) if kind == "kana": return lang != "ja" if kind == "han": return lang not in ("ja", "zh") return kind == "latin" and lang not in ("en", "id") def decide_language(text, lang, candidates): """候補言語に限定して識別した言語 lang を、その言語で復号した認識結果の文字体系で補正する。 補正後の言語も候補言語の中から選ぶ。これはモデルの出力ではなく本アプリの後処理であり、 表記の矛盾が明らかな場合に限って働く。 """ kind = script_kind(text) if kind == "kana" and "ja" in candidates: return "ja" if kind == "han" and lang not in ("ja", "zh"): han = [c for c in ("zh", "ja") if c in candidates] return han[0] if han else lang if kind == "latin": latin = [c for c in candidates if c in ("en", "id")] if len(latin) == 1 and lang not in latin: return latin[0] return lang def looks_looped(text): """同じ断片の繰り返しだけで構成されているかを判定する。""" compact = "".join(text.split()) n = len(compact) if n >= 12: for size in range(1, n // 3 + 1): repeats = n // size if repeats < 3: break if compact[:size] * repeats == compact[:size * repeats]: return True words = text.split() return len(words) >= 6 and collections.Counter(words).most_common(1)[0][1] >= len(words) * 0.6 def is_hallucination(text): """音声に存在しない文字列の生成(ハルシネーション)とみなせる出力かを判定する。""" t = text.strip() if not t: return True if len(t) <= 60 and any(p.lower() in t.lower() for p in HALLUCINATION_PHRASES): return True compact = t.replace(" ", "") return (len(compact) >= 8 and len(set(compact)) <= 2) or looks_looped(t) def compare_key(text): return re.sub(r"[\s\W_]+", "", text, flags=re.UNICODE).lower() def plausible_speech(parts, duration): """認識された区間の合計長から、発話とみなせる内容があるかを判定する。 発話開始のしきい値を低くしているため、雑音による区間はここで除く。合計長が MIN_SPEECH_SEC 未満の場合と、1 秒未満かつ発話区間全体の長さの LOW_SPEECH_RATIO 未満の場合は発話とみなさない。 """ speech = sum(p.end - p.start for p in parts) if speech < MIN_SPEECH_SEC: return False return not (duration > 0.0 and speech < 1.0 and speech / duration < LOW_SPEECH_RATIO) def short_noise(parts, text): """ごく短い出力と謝辞のみの出力は、非発話確率が高い場合に限り雑音として破棄する。""" key = compare_key(text) return ((len(key) <= SHORT_TEXT_CHARS or key in THANKS_ONLY_KEYS) and max(p.no_speech for p in parts) >= SHORT_TEXT_NO_SPEECH_MAX) _SENTENCE_BREAK = re.compile(r"(?<=[。.!?!?…])\s*|(?<=[.?!])\s+") def split_sentences(text, limit=220): """文単位に分割する(NLLB-200 は文単位の翻訳を想定している)。 limit 文字を超える文は読点・カンマで分ける。英語の略語(Dr. など)の直後でも分割するため、 略語を含む文は複数の文として翻訳される(ヘルプの限界の項に記載)。 """ out = [] for piece in (p.strip() for p in _SENTENCE_BREAK.split(text.strip()) if p and p.strip()): while len(piece) > limit: cut = max(piece.rfind(mark, 0, limit) for mark in "、,,") cut = cut + 1 if cut > limit // 3 else limit out.append(piece[:cut].strip()) piece = piece[cut:].strip() if piece: out.append(piece) return out def format_sec(sec): return f"{int(sec // 60):02d}:{int(sec % 60):02d}" # ---------------------------------------------------------------- 相手向け表示の行分割 # Tk のラベルの自動折り返し(wraplength)は空白の位置でしか改行しないため、空白を含む日本語・ # 中国語の文では空白の手前で改行されて行末が大きく空き、文字サイズの見積りも実際の行数と合わなく # なる。そこで、フォントの実測幅に基づいて行を分け、改行を明示したうえでラベルに渡す。 _CJK = "\u2E80-\u9FFF\uF900-\uFAFF\uFF00-\uFFEF" _CJK_CHAR = re.compile(f"[{_CJK}]") _WRAP_TOKEN = re.compile(rf"\s+|[{_CJK}]|[^\s{_CJK}]+") # 空白 / 全角の 1 字 / 空白を含まない語 # 行頭に置かない文字(行頭禁則)。該当する字で行を送る場合は、直前の 1 字とともに次の行へ送る。 NO_LINE_START = frozenset("、。,.・:;?!)]}〕〉》」』】”’ー…‥々ゝゞヽヾ" "ぁぃぅぇぉっゃゅょゎァィゥェォッャュョヮヵヶ%") def wrap_text(text, measure, width): """文字列を幅 width [px] 以内の行に分ける。measure(s) は s の描画幅 [px]。 全角の文字はどこでも改行でき、空白で区切られた語は語の境界で改行する(1 行に収まらない語は 文字単位で分ける)。 """ lines, line, line_w, space = [], [], 0, False for tok in _WRAP_TOKEN.findall(text): if tok.isspace(): space = bool(line) continue gap = measure(" ") if space else 0 space = False tok_w = measure(tok) if line and line_w + gap + tok_w > width: carry = [] if tok in NO_LINE_START and len(line) >= 2 and len(line[-1]) == 1 and line[-2] != " ": carry = [line.pop()] lines.append("".join(line).rstrip()) line, line_w, gap = carry, sum(measure(c) for c in carry), 0 if not line and tok_w > width: chunk = "" for ch in tok: if chunk and measure(chunk + ch) > width: lines.append(chunk) chunk = "" chunk += ch line, line_w = [chunk], measure(chunk) continue if gap: line.append(" ") line.append(tok) line_w += gap + tok_w if line: lines.append("".join(line).rstrip()) return lines def wrap_tail(text, measure, width, max_lines): """max_lines 行に収まらない場合は先頭を「…」で省き、末尾(最新の内容)が収まる行を返す。""" lines = wrap_text(text, measure, width) if len(lines) <= max_lines: return lines fits = lambda cut: len(wrap_text("…" + text[cut:].lstrip(), measure, width)) <= max_lines low, high = 1, len(text) while low < high: # 収まる最小の省略位置を二分探索で求める mid = (low + high) // 2 if fits(mid): high = mid else: low = mid + 1 # 空白で区切る語の途中で切れた場合は、次の語の先頭まで進める(省く量が増えるだけなので収まる) in_word = lambda ch: not ch.isspace() and not _CJK_CHAR.match(ch) if low < len(text) and in_word(text[low - 1]) and in_word(text[low]): next_space = text.find(" ", low) if next_space != -1: low = next_space return wrap_text("…" + text[low:].lstrip(), measure, width) def text_measurer(font): """フォントの現在の設定での描画幅を、語句ごとに記憶して返す関数を作る。""" cache = {} def measure(s): w = cache.get(s) if w is None: w = cache[s] = font.measure(s) return w return measure # ---------------------------------------------------------------- モデルの取得 def pick_compute_type(device): """装置が対応する計算型のうち、優先順で最初のものを選ぶ。""" supported = ctranslate2.get_supported_compute_types(device) return next(c for c in COMPUTE_PREFERENCE[device] if c in supported) def dir_bytes(path): """フォルダ内のファイルの総バイト数(ダウンロード進捗の表示に使う)。 取得中のファイルは集計の途中で名前が変わり見つからなくなることがあるため、その時点で 見つからないファイルは数えない(os.walk も、走査中に消えたフォルダを読み飛ばす)。 ここでの try は、走査と stat の間にファイルが消えるという競合を避けるためのもので、 演算の失敗を別の処理で置き換えるものではない。 """ total = 0 for folder, _dirs, files in os.walk(path): for name in files: try: total += os.stat(os.path.join(folder, name)).st_size except FileNotFoundError: pass return total def hub_total_bytes(repo_id, patterns): """Hugging Face Hub 上で取得対象となるファイルの合計バイト数。""" from huggingface_hub.hf_api import HfApi info = HfApi().model_info(repo_id, files_metadata=True) return sum((s.size or 0) for s in info.siblings if any(fnmatch.fnmatch(s.rfilename, p) for p in patterns)) def ensure_model(repo_id, local_dir, patterns, progress): """モデル一式を用意する。取得済みなら通信しない。progress(取得済みバイト数, 総バイト数)。""" marker = local_dir / READY_MARK if marker.exists(): return local_dir # huggingface_hub はパッケージ直下の名前を遅延読み込みで提供するため、PyInstaller の静的解析で # 定義元のモジュールが同梱されないことがある。定義元から直接読み込む。 from huggingface_hub._snapshot_download import snapshot_download local_dir.mkdir(parents=True, exist_ok=True) total = hub_total_bytes(repo_id, patterns) stop = threading.Event() def tick(): while not stop.wait(0.25): progress(dir_bytes(local_dir), total) watcher = threading.Thread(target=tick, daemon=True) watcher.start() try: snapshot_download(repo_id=repo_id, local_dir=local_dir, allow_patterns=list(patterns)) finally: stop.set() watcher.join(timeout=1.0) marker.write_text(f"{repo_id}\n{datetime.now():%Y-%m-%d %H:%M:%S}\n", encoding="utf-8") progress(total, total) return local_dir def ensure_release_model(name, progress): """sherpa-onnx の公式リリースから音声合成モデルの書庫(tar.bz2)を取得して展開する。 書庫の最上位フォルダ名はモデル名と同じ。取得済みなら通信しない。 progress(取得済みバイト数, 総バイト数)。 """ local_dir = TTS_DIR / name marker = local_dir / READY_MARK if marker.exists(): return local_dir TTS_DIR.mkdir(parents=True, exist_ok=True) url = TTS_RELEASE_URL.format(name) archive = TTS_DIR / f"{name}.tar.bz2.part" try: with urllib.request.urlopen(url, timeout=60) as response, archive.open("wb") as out: total = int(response.headers.get("Content-Length") or 0) got = 0 while True: chunk = response.read(1 << 20) if not chunk: break out.write(chunk) got += len(chunk) progress(got, total) if total and got != total: raise OSError(f"{name}: ダウンロードが途中で終了しました({got} / {total} バイト)") with tarfile.open(archive, "r:bz2") as tar: # 書庫外への書き込みを防ぐ filter は、Python 3.12 以降と、3.8.17・3.9.17・3.10.12・ # 3.11.4 以降の各版にある(Windows 向けインストーラの最終版である 3.9.13・3.10.11 には無い) tar.extractall(TTS_DIR, **({"filter": "data"} if hasattr(tarfile, "data_filter") else {})) finally: archive.unlink(missing_ok=True) if not local_dir.is_dir(): raise OSError(f"{name}: 書庫の構成が想定と異なります") marker.write_text(f"{url}\n{datetime.now():%Y-%m-%d %H:%M:%S}\n", encoding="utf-8") return local_dir # ---------------------------------------------------------------- 推論エンジン class Engine: """音声認識(faster-whisper)と機械翻訳(CTranslate2 形式の NLLB-200)をまとめて扱う。 ビーム幅は Params から復号のたびに読むため、動作中の変更が次の復号から反映される。 """ def __init__(self, params): self.p = params self.device = self.model_key = self.mt_key = None self.compute_type = "" self.asr = self.batched = self.translator = self.tokenizer = None def load(self, device, model_key, mt_key, report): """必要ならモデルを取得し、指定の装置へ読み込む。report(状態キー, 取得済み, 総量)。 変更のあった側(認識または翻訳)だけを読み込み直す。装置を変えた場合は両方を読み込み直す。 """ from faster_whisper import BatchedInferencePipeline, WhisperModel if device != self.device: self.model_key = self.mt_key = None reload_mt, reload_asr = mt_key != self.mt_key, model_key != self.model_key if not (reload_mt or reload_asr): return # 旧モデルを先に解放する(メモリを二重に確保しないため)。途中で失敗した場合は、 # 次の開始時に読み込み直すよう、キーも消しておく。 if reload_mt: self.translator = self.tokenizer = self.mt_key = None if reload_asr: self.asr = self.batched = self.model_key = None gc.collect() self.device = device compute_type = pick_compute_type(device) self.compute_type = compute_type download = lambda got, total: report("downloading", got, total) if reload_mt: mt_name, mt_repo = MT_SPECS[mt_key] mt_dir = ensure_model(mt_repo, MODEL_DIR / mt_name, MT_PATTERNS, download) report("loading", 0, 0) self.tokenizer = Tokenizer.from_file(str(mt_dir / MT_TOKENIZER_FILE)) self.translator = ctranslate2.Translator( str(mt_dir), device=device, compute_type=compute_type, intra_threads=CPU_THREADS) self.mt_key = mt_key if reload_asr: name, repo = ASR_SPECS[model_key] asr_dir = ensure_model(repo, ASR_ROOT / name, ASR_PATTERNS, download) report("loading", 0, 0) self.asr = WhisperModel(str(asr_dir), device=device, compute_type=compute_type, cpu_threads=CPU_THREADS) self.batched = BatchedInferencePipeline(model=self.asr) self.model_key = model_key report("warming", 0, 0) self._warm_up() def _warm_up(self): """最初の発話での初期化による遅延を避けるため、認識と翻訳を一度ずつ実行する。 無音を与えると温度フォールバックで再復号が繰り返されるため、音声帯域内で振幅が変動する 短い信号を用い、温度は 0 のみ、VAD は無効にする。得られた文字列は用いない。 """ t = np.arange(int(SAMPLE_RATE * 0.5), dtype=np.float32) / SAMPLE_RATE tone = (0.05 * np.sin(2 * np.pi * 220.0 * t) * (1.0 + 0.5 * np.sin(2 * np.pi * 4.0 * t))).astype(np.float32) segments, _info = self.asr.transcribe(tone, language="en", beam_size=1, temperature=[0.0], condition_on_previous_text=False, vad_filter=False) list(segments) # segments は遅延評価のため、消費して復号まで実行する self.translate("Hello.", "en", "ja") def describe(self): """実行条件の記述(ヘルプの記載とログの再現条件に用いる)。""" asr = ASR_SPECS[self.model_key] if self.model_key else ("", "") mt = MT_SPECS[self.mt_key] if self.mt_key else ("", "") return dict(asr_label=asr[0], asr_repo=asr[1], mt_label=mt[0], mt_repo=mt[1], device=self.device or "", compute_type=self.compute_type) # -------------------------------------------------- 音声認識 def _run(self, audio, language, batched): options = dict( language=language, beam_size=self.p.asr_beam, # 直前の認識結果を次の区間の復号にプロンプトとして与えない(誤りや繰り返しの連鎖を防ぐ) condition_on_previous_text=False, # 圧縮率がしきい値を超えた場合、温度を上げて再復号する temperature=list(ASR_TEMPERATURES), compression_ratio_threshold=ASR_COMPRESSION_MAX, log_prob_threshold=None, # 平均対数確率による棄却はしない no_speech_threshold=ASR_NO_SPEECH_MAX, # Silero VAD で非発話区間を除いてから認識する(誤認識と処理時間の両方を減らす) vad_filter=True, vad_parameters=dict(VAD_PARAMS), ) if batched: return self.batched.transcribe(audio, batch_size=FILE_BATCH_SIZE, **options) return self.asr.transcribe(audio, **options) @staticmethod def _collect(segments): """非発話確率または圧縮率がしきい値以上の区間を除く。""" return [Part(s.start, s.end, s.text.strip(), s.no_speech_prob, s.compression_ratio) for s in segments if s.no_speech_prob < ASR_NO_SPEECH_MAX and s.compression_ratio < ASR_COMPRESSION_MAX and s.text.strip()] def _detect_language(self, speech, candidates): """Silero VAD で非発話部分を除いた音声 speech の先頭 30 秒で言語を識別し、候補言語のうち 事後確率が最大の言語を選ぶ。戻り値は (言語, 全言語の事後確率の辞書)。 faster-whisper に language=None を渡すと、Whisper が対応する約 100 言語から識別した 言語で復号するため、候補外の言語(日本語とインドネシア語の会話での英語など)が 選ばれると、認識結果がその言語への翻訳や誤った表記になる。これを避けるため、識別と 復号を分け、復号には候補言語のみを指定する。 """ _lang, _prob, all_probs = self.asr.detect_language(audio=speech) probs = dict(all_probs or {}) usable = [c for c in candidates if c in probs] if not usable: # 候補が 1 つも含まれない場合は、推測で埋めずに失敗させる raise RuntimeError("言語識別の結果に候補言語が含まれていません") return max(usable, key=lambda c: probs[c]), probs def recognize(self, audio, fixed_lang, candidates, batched=False): """音声(配列またはファイルのパス)を文字化する。 fixed_lang を指定した場合は言語識別を行わない(posterior は None)。 戻り値は Recognition(区間の一覧, 話者の言語, 言語識別の事後確率, 全言語の事後確率, 音声全体の長さ [秒], 文字体系による補正で復号し直したか)。 発話が検出されない場合は lang を None とする。 """ if fixed_lang is not None: segments, info = self._run(audio, fixed_lang, batched) return Recognition(self._collect(segments), fixed_lang, None, None, info.duration, False) from faster_whisper import decode_audio from faster_whisper.vad import VadOptions, get_speech_timestamps if not isinstance(audio, np.ndarray): audio = decode_audio(audio, sampling_rate=SAMPLE_RATE) chunks = get_speech_timestamps(audio, VadOptions(**VAD_PARAMS)) if not chunks: # 発話が無ければ、言語識別も認識も行わない return Recognition([], None, None, None, audio.size / SAMPLE_RATE, False) speech = np.concatenate([audio[c["start"]:c["end"]] for c in chunks]) lang, probs = self._detect_language(speech, candidates) segments, info = self._run(audio, lang, batched) parts = self._collect(segments) rerun = False corrected = decide_language(" ".join(p.text for p in parts), lang, candidates) if parts and corrected != lang: # 復号は言語トークンに条件付けられるため、補正後の言語を指定して認識し直す。 # 認識し直した結果が得られない、または表記が矛盾する場合は、最初の結果と言語を保つ。 segments, info2 = self._run(audio, corrected, batched) parts2 = self._collect(segments) if parts2 and not script_conflicts(" ".join(p.text for p in parts2), corrected): parts, info, lang, rerun = parts2, info2, corrected, True return Recognition(parts, lang, probs.get(lang, 0.0), probs, info.duration, rerun) # -------------------------------------------------- 機械翻訳 def translate(self, text, src, dst): """NLLB-200 の入力形式に従い、原文を [原言語コード, トークン列, ] とし、 出力の先頭に目的言語コードを与えて翻訳する。 戻り値は Translation(訳文, [(文, 入力トークン数, 訳文)])。 """ sentences = split_sentences(text) src_code, dst_code = NLLB_CODE[src], NLLB_CODE[dst] encodings = self.tokenizer.encode_batch(sentences, add_special_tokens=False) results = self.translator.translate_batch( [[src_code] + e.tokens + [EOS_TOKEN] for e in encodings], target_prefix=[[dst_code]] * len(sentences), beam_size=self.p.mt_beam, max_decoding_length=MT_MAX_DECODING, no_repeat_ngram_size=MT_NO_REPEAT_NGRAM["cjk" if dst in NO_SPACE_LANGS else "spaced"], max_batch_size=8, ) pieces = [] for result in results: ids = [self.tokenizer.token_to_id(t) for t in result.hypotheses[0] if t not in (dst_code, EOS_TOKEN)] pieces.append(self.tokenizer.decode([i for i in ids if i is not None], skip_special_tokens=True).strip()) rows = [(s, len(e.tokens), p) for s, e, p in zip(sentences, encodings, pieces)] return Translation((("" if dst in NO_SPACE_LANGS else " ").join(p for p in pieces if p)), rows) # ---------------------------------------------------------------- 音声合成(内蔵: sherpa-onnx、別プロセス) def _prefer_bundled_onnxruntime(): """sherpa-onnx に同梱の DLL を、System32 などにある別の版の onnxruntime.dll より先に探させる。""" spec = importlib.util.find_spec("sherpa_onnx") if spec is None or not spec.origin: return # 未導入の場合は、続く import で ModuleNotFoundError になる package = Path(spec.origin).parent for folder in (package / "lib", package): if folder.is_dir(): add_dll_dir(folder) def builtin_tts_config(sherpa_onnx, key): """内蔵音声モデルの設定を作る(ファイル構成は sherpa-onnx の各モデルの用例に従う)。""" folder = TTS_DIR / BUILTIN_TTS_MODELS[key]["name"] f = lambda name: str(folder / name) if key == "supertonic": model = sherpa_onnx.OfflineTtsModelConfig( supertonic=sherpa_onnx.OfflineTtsSupertonicModelConfig( duration_predictor=f("duration_predictor.int8.onnx"), text_encoder=f("text_encoder.int8.onnx"), vector_estimator=f("vector_estimator.int8.onnx"), vocoder=f("vocoder.int8.onnx"), tts_json=f("tts.json"), unicode_indexer=f("unicode_indexer.bin"), voice_style=f("voice.bin")), num_threads=BUILTIN_THREADS, provider="cpu") config = sherpa_onnx.OfflineTtsConfig(model=model) else: model = sherpa_onnx.OfflineTtsModelConfig( vits=sherpa_onnx.OfflineTtsVitsModelConfig( model=f("zh_CN-xiao_ya-medium.onnx"), lexicon=f("lexicon.txt"), tokens=f("tokens.txt")), num_threads=BUILTIN_THREADS, provider="cpu") # 電話番号・日付・数字の読み方の規則 config = sherpa_onnx.OfflineTtsConfig( model=model, rule_fsts=",".join(f(n) for n in ("phone.fst", "date.fst", "number.fst"))) if not config.validate(): raise RuntimeError(f"音声モデルのファイルがそろっていません: {folder}") return config def builtin_speed(rate): """SAPI5 の Rate(−10〜+10)を、内蔵音声の speed(倍率)に換算する。 speed = 2^(Rate/10) とする。Rate 0 で 1.0 倍、+10 で 2 倍、−10 で 0.5 倍になる。SAPI5 の Rate の 聞こえ方は音声エンジンに依存するため、この換算は本アプリが定めた対応関係であり、両者の話速が 同一になることを保証するものではない。 """ return 2.0 ** (int(rate) / 10.0) def play_builtin(sherpa_onnx, tts, key, text, lang, rate, cancelled): """文ごとに合成して既定の出力デバイスで再生する。cancelled() が真になれば直ちに中断する。""" gen = sherpa_onnx.GenerationConfig() gen.sid = BUILTIN_SPEAKER_ID gen.speed = builtin_speed(rate) if key == "supertonic": gen.num_steps = BUILTIN_FLOW_STEPS gen.extra = {"lang": lang} sample_rate = tts.sample_rate step = max(1, int(sample_rate * BUILTIN_CHUNK_SEC)) with sd.OutputStream(samplerate=sample_rate, channels=1, dtype="float32") as out: for sentence in split_sentences(text): if cancelled(): out.abort() return audio = np.asarray(tts.generate(sentence, gen).samples, dtype=np.float32) if audio.size == 0: continue peak = float(np.max(np.abs(audio))) if peak > 0.0: audio *= min(BUILTIN_PEAK / peak, BUILTIN_MAX_GAIN) for i in range(0, audio.size, step): if cancelled(): out.abort() # 出力バッファに残った音も捨てる return out.write(audio[i:i + step].reshape(-1, 1)) # with を抜けるときの stop() は、出力バッファの音を再生し終えるまで待つ def builtin_tts_process(requests, replies, cancel): """内蔵音声合成の子プロセスの本体。 要求 : ("load", 番号, モデル) / ("say", 番号, 文, 言語, 中断番号, Rate) / None(終了) 応答 : (番号, 成否, 失敗の内容)。"say" は再生を終えるか中断した時点で応答する。 cancel の値が要求時の中断番号から変われば、再生を中断する。 失敗は応答として親プロセスへ返し、親プロセスで例外として扱う(子プロセスで握りつぶさない)。 """ sherpa_onnx, engines = None, {} for message in iter(requests.get, None): kind, seq = message[0], message[1] try: if sherpa_onnx is None: _prefer_bundled_onnxruntime() import sherpa_onnx # PyInstaller が同梱の対象として検出できるよう import 文で書く if kind == "load": if message[2] not in engines: engines[message[2]] = sherpa_onnx.OfflineTts( builtin_tts_config(sherpa_onnx, message[2])) else: _kind, _seq, text, lang, token, rate = message key = BUILTIN_MODEL_FOR_LANG[lang] play_builtin(sherpa_onnx, engines[key], key, text, lang, rate, lambda: cancel.value != token) replies.put((seq, True, "")) except Exception as exc: # 失敗を親プロセスへ伝える(応答が無いと親が待ち続けるため) replies.put((seq, False, f"{type(exc).__name__}: {exc}")) class BuiltinTts: """内蔵音声合成の子プロセスを管理する(親プロセスは sherpa-onnx を読み込まない)。 子プロセスの失敗・終了と応答の時間切れは例外として送出し、アプリケーションの失敗の受け口で 処理を停止して原因を表示する。 """ def __init__(self): self.loaded = set() # 現在の子プロセスに読み込み済みのモデル self._prepare_lock = threading.Lock() self._send_lock = threading.Lock() self._waiting = {} # 番号 -> [threading.Event, 成否, 失敗の内容] self._seq = 0 self._proc = self._requests = self._cancel = None @staticmethod def downloaded(key): return (TTS_DIR / BUILTIN_TTS_MODELS[key]["name"] / READY_MARK).exists() def alive(self): return self._proc is not None and self._proc.is_alive() def is_ready(self, lang): return BUILTIN_MODEL_FOR_LANG[lang] in self.loaded and self.alive() def prepare(self, key, report): """モデルを取得して子プロセスに読み込ませる(呼び出し元のスレッドで完了まで待つ)。 report(状態キー, 取得済みバイト数, 総バイト数) で進捗を知らせる。 """ with self._prepare_lock: if key in self.loaded and self.alive(): return ensure_release_model(BUILTIN_TTS_MODELS[key]["name"], lambda got, total: report("downloading", got, total)) report("loading", 0, 0) if not self.alive(): self._start_process() self._request("load", key, timeout=BUILTIN_LOAD_TIMEOUT_SEC) self.loaded.add(key) def say(self, text, lang, rate, interrupted): """読み上げを終えるまで待つ。interrupted() が真になれば再生を中断させる。""" self._request("say", text, lang, self._cancel.value, int(rate), interrupted=interrupted) def shutdown(self): if self._proc is None: return with self._cancel.get_lock(): self._cancel.value += 1 self._requests.put(None) self._proc.join(timeout=2.0) if self._proc.is_alive(): self._proc.terminate() self._proc = None def _start_process(self): self.loaded.clear() # 前の子プロセスに読み込んだモデルは使えない ctx = multiprocessing.get_context("spawn") self._requests, replies = ctx.Queue(), ctx.Queue() self._cancel = ctx.Value("i", 0) self._proc = ctx.Process(target=builtin_tts_process, name="builtin-tts", daemon=True, args=(self._requests, replies, self._cancel)) self._proc.start() threading.Thread(target=self._pump_replies, args=(replies,), daemon=True).start() def _pump_replies(self, replies): """子プロセスの応答を、応答を待っている要求に届ける。""" while True: seq, ok, detail = replies.get() with self._send_lock: slot = self._waiting.pop(seq, None) if slot is not None: slot[1:] = [ok, detail] slot[0].set() def _request(self, *message, timeout=None, interrupted=None): """要求を送って応答を待つ。interrupted() が真になれば、再生の中断を一度だけ求める。""" with self._send_lock: self._seq += 1 slot = self._waiting[self._seq] = [threading.Event(), False, ""] self._requests.put((message[0], self._seq) + message[1:]) deadline = None if timeout is None else time.monotonic() + timeout cancelled = False while not slot[0].wait(0.05): if not self.alive(): self.loaded.clear() raise RuntimeError("内蔵音声合成のプロセスが終了しました") if deadline is not None and time.monotonic() > deadline: raise TimeoutError(f"内蔵音声合成から {timeout:.0f} 秒以内に応答がありませんでした") if interrupted is not None and not cancelled and interrupted(): cancelled = True with self._cancel.get_lock(): self._cancel.value += 1 if not slot[1]: raise RuntimeError(f"内蔵音声合成: {slot[2]}") # ---------------------------------------------------------------- 音声合成(Windows SAPI5 と内蔵音声) # 言語ごとに、使用する Windows の音声を LANGID(Windows の言語識別子)の優先順で探す。 # en : en-US → en-GB → en-AU → en-CA # zh : zh-CN → zh-SG(いずれも簡体字の標準中国語) # Windows に音声が無い言語は内蔵音声(BuiltinTts)で読み上げる。 SAPI_VOICE_ORDER = { "ja": (0x411,), "id": (0x421,), "en": (0x409, 0x809, 0xC09, 0x1009), "zh": (0x804, 0x1004), } SVSF_ASYNC = 1 SVSF_PURGE_BEFORE_SPEAK = 2 PUMP_INTERVAL_SEC = 0.05 SPEAK_POLL_MS = 50 SPEAK_TIMEOUT_SEC = 60.0 SPEAK_QUEUE_MAX = 8 SPEAK_TAIL_SEC = 0.4 # 再生終了直後の残響も自己音声として扱う時間 ONECORE_SUBKEY = r"SOFTWARE\Microsoft\Speech_OneCore\Voices" ONECORE_VOICES_KEY = r"HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\Speech_OneCore\Voices" def onecore_voices_exist(): """OneCore 音声の登録先がレジストリに存在するかを確かめる(有無の判定であり、 失敗を別の処理で置き換えるものではない)。""" try: winreg.CloseKey(winreg.OpenKey(winreg.HKEY_LOCAL_MACHINE, ONECORE_SUBKEY)) return True except OSError: return False class Speaker: """訳文を読み上げる。Windows の音声があればそれを使い、無い言語は内蔵音声を使う。 読み上げは 1 本の待ち行列で順に行い、両者の音声が重ならないようにする。 SAPI の COM オブジェクトは専用スレッド内でのみ扱う。読み上げ速度は Params から文ごとに読む。 """ def __init__(self, params): self.p = params self.queue = queue.Queue() self.voice_for_lang = {} self.voice_name = {} self.builtin = BuiltinTts() self.ready = threading.Event() self._purge = threading.Event() self._stop = threading.Event() self._speaking = False self._last_end = 0.0 self._thread = None self.ensure_running() def ensure_running(self): """読み上げのスレッドを起動する(失敗によって終了していた場合は起動し直す)。""" if self._thread is None or not self._thread.is_alive(): self._thread = threading.Thread(target=self._run, daemon=True) self._thread.start() def has_windows_voice(self, lang): return lang in self.voice_for_lang def can_speak(self, lang): return self.has_windows_voice(lang) or self.builtin.is_ready(lang) def is_speaking(self): """再生中か(再生終了直後の SPEAK_TAIL_SEC も含む)。""" if self._speaking or not self.queue.empty(): return True return time.monotonic() - self._last_end < SPEAK_TAIL_SEC def speak(self, text, lang): if not text or self._stop.is_set() or not self.can_speak(lang): return while self.queue.qsize() >= SPEAK_QUEUE_MAX: self._get_nowait() self.queue.put((text, lang)) def stop_speaking(self): self._drain() self._purge.set() def shutdown(self): self._stop.set() self._drain() self.queue.put(None) self.builtin.shutdown() def _interrupted(self): return self._stop.is_set() or self._purge.is_set() def _get_nowait(self): try: return self.queue.get_nowait() except queue.Empty: return None def _drain(self): while self._get_nowait() is not None: pass def _select_voices(self, voice): """SAPI の属性クエリで、言語ごとに使う音声を 1 つ決める(SAPI5 の一覧、次に OneCore の一覧)。""" sources = [voice.GetVoices] if onecore_voices_exist(): category = win32com.client.Dispatch("SAPI.SpObjectTokenCategory") category.SetId(ONECORE_VOICES_KEY, False) sources.append(category.EnumerateTokens) for lang, langids in SAPI_VOICE_ORDER.items(): found = (tokens for langid in langids for enumerate_tokens in sources for tokens in (enumerate_tokens(f"Language={langid:x}"),) if tokens.Count > 0) tokens = next(found, None) if tokens is not None: self.voice_for_lang[lang] = tokens.Item(0) self.voice_name[lang] = tokens.Item(0).GetDescription() def _run(self): pythoncom.CoInitialize() voice = win32com.client.Dispatch("SAPI.SpVoice") if not self.ready.is_set(): # 音声の選択は最初の起動時に一度だけ行う self._select_voices(voice) self.ready.set() while not self._stop.is_set(): pythoncom.PumpWaitingMessages() if self._purge.is_set(): self._purge.clear() self._drain() voice.Speak("", SVSF_ASYNC | SVSF_PURGE_BEFORE_SPEAK) try: item = self.queue.get(timeout=PUMP_INTERVAL_SEC) except queue.Empty: continue if item is None: break text, lang = item self._speaking = True try: if lang in self.voice_for_lang: voice.Voice = self.voice_for_lang[lang] voice.Rate = self.p.tts_rate # SAPI5 の Rate(−10〜+10) self._speak_one(voice, text) else: self.builtin.say(text, lang, self.p.tts_rate, self._interrupted) finally: self._speaking = False self._last_end = time.monotonic() voice.Speak("", SVSF_ASYNC | SVSF_PURGE_BEFORE_SPEAK) pythoncom.CoUninitialize() def _speak_one(self, voice, text): voice.Speak(text, SVSF_ASYNC) deadline = time.monotonic() + SPEAK_TIMEOUT_SEC while time.monotonic() < deadline: if self._stop.is_set() or self._purge.is_set(): self._purge.clear() self._drain() break pythoncom.PumpWaitingMessages() if voice.WaitUntilDone(SPEAK_POLL_MS): return voice.Speak("", SVSF_ASYNC | SVSF_PURGE_BEFORE_SPEAK) # ---------------------------------------------------------------- 入力デバイス def usable_input_devices(): """16 kHz・モノラルで実際に開ける入力デバイスだけを (番号, 表示名) の一覧で返す。 check_input_settings の失敗は「その設定では開けない」という事実の判定であり、 開けないデバイスを一覧から除くために用いる(代わりの設定で開き直すことはしない)。 """ devices = [] for index, info in enumerate(sd.query_devices()): if info["max_input_channels"] < 1: continue try: sd.check_input_settings(device=index, channels=1, dtype="float32", samplerate=SAMPLE_RATE) except (sd.PortAudioError, ValueError): continue devices.append((index, f"{info['name']} [{sd.query_hostapis(info['hostapi'])['name']}]")) return devices def default_device_position(devices): default = sd.default.device[0] return next((pos for pos, (index, _name) in enumerate(devices) if index == default), 0) # ---------------------------------------------------------------- 版の記録 PACKAGE_DISTS = ("ctranslate2", "faster-whisper", "tokenizers", "numpy", "sounddevice", "huggingface-hub", "pywin32") def library_versions(): """この実行で用いるライブラリの版(ログの再現条件とヘルプに記す)。""" rows = [f"Python {sys.version.split()[0]}"] rows += [f"{name} {importlib.metadata.version(name)}" for name in PACKAGE_DISTS] if importlib.util.find_spec("sherpa_onnx"): rows.append(f"sherpa-onnx {importlib.metadata.version('sherpa-onnx')}") else: rows.append("sherpa-onnx 未導入(内蔵音声合成は使用できない)") return rows # ---------------------------------------------------------------- 設定の保存 def load_settings(): """保存された設定を読む。戻り値は (設定の辞書, 利用者への通知)。 JSON として壊れている場合は、そのファイルを退避したうえで既定値を用い、退避したことを 画面に通知する(黙って既定値に切り替えない)。退避するのは、次回の保存で上書きされて 内容が失われるのを防ぐためである。 """ if not SETTINGS_PATH.exists(): return {}, "" try: data = json.loads(SETTINGS_PATH.read_text(encoding="utf-8")) except (OSError, ValueError): broken = SETTINGS_PATH.with_name(f"settings.broken-{datetime.now():%Y%m%d_%H%M%S}.json") SETTINGS_PATH.replace(broken) return {}, f"設定ファイルを読み取れなかったため {broken.name} に退避し、既定値で起動しました。" if not isinstance(data, dict): return {}, "設定ファイルの内容が辞書でないため、既定値で起動しました。" return data, "" def save_settings(data): """一時ファイルに書いてから置き換え、書き込みの途中で終了しても設定ファイルが壊れないようにする。""" temp = SETTINGS_PATH.with_suffix(".tmp") temp.write_text(json.dumps(data, ensure_ascii=False, indent=2), encoding="utf-8") temp.replace(SETTINGS_PATH) # ---------------------------------------------------------------- ヘルプ画面の本文 # 記載の方針 : コードから確定できる事実だけを書く。外部の仕様に依存する値は、その旨を明記する。 # 推測で補わない。数値はコード内の定数と一致させる。 GUIDE = ( ("h1", "音声翻訳アプリの使い方と処理の説明"), ("p", "このタブは説明のための画面です。上部の「実行」タブをクリックすると、元の操作画面に戻ります。" "「処理過程」タブで、発話ごとの算出過程を確認できます。"), ("h2", "1. このアプリが行うこと"), ("p", "マイクまたは音声ファイルから得た音声を、この PC 上で文字起こしし、指定した言語へ翻訳して" "表示します。必要に応じて訳文を音声合成で読み上げます。音声認識・翻訳・音声合成はすべて" "この PC 上で実行し、音声とテキストを外部へ送信しません。通信が発生するのは、各モデルを" "初めて使うときの重みの取得だけです。"), ("p", "想定する利用場面は、日本語・中国語・インドネシア語・英語を話す人が同席する会議、講義、" "窓口での対話です。操作者(この画面を操作する人)が内容を読み、必要なら「相手向け表示」を" "開いて、訳文を大きな文字で相手に見せられます。"), ("h2", "2. 操作手順"), ("li", "「翻訳方向」を選びます。固定の 12 通り(例 : インドネシア語 → 日本語)、会話の 6 通り" "(2 言語を相互に翻訳し、発話ごとに言語を自動判定)、文字起こしのみの 1 通りがあります。"), ("li", "音声の入力元を「マイク」または「音声ファイル」から選びます。マイクは 16 kHz・モノラルで" "開けるものだけが一覧に表示されます。"), ("li", "必要に応じて、音声認識モデル、復号のビーム幅、翻訳モデル、実行デバイス、使用環境を選びます。"), ("li", "「▶ 開始」を押します(F5 キーでも同じです)。マイクの場合は 1 秒間、暗騒音を測定します。" "この間は話しかけないでください。"), ("li", "認識結果と訳文が画面に追加されます。スライダーを動かすと、次の発話の処理から設定が" "反映されます。"), ("li", "「■ 停止」で終了します。会話ログは logs フォルダに自動で保存されます。"), ("li", "「処理過程」タブで、発話ごとの判定値と中間結果を確認できます。「TSV で保存」を押すと、" "その内容を logs フォルダに保存します。"), ("h2", "3. 動作環境"), ("p", "Windows 10 以降。CPU の PC と、CUDA 対応 GPU を搭載した PC で動作します。GPU で実行する" "には、CUDA 12 用の cuBLAS と cuDNN(9。ctranslate2 4.4 以前は 8)を読み込める必要が" "あります。読み込めない場合は、画面の「実行デバイス」で GPU を選べません。"), ("p", "画面は「表示」の選択で、ノート PC 向け(高さ 768 画素の画面に収まる大きさ)と全画面表示を" "切り替えられます。全画面表示は Esc キーで解除できます。"), ("h2", "4. 使用するモデルとライブラリ"), ("p", "音声認識 : OpenAI の Whisper を CTranslate2 で実行する faster-whisper を用います。選択肢は" "次の 3 つです。"), ("li", "標準 : small(パラメータ数 約 244M、取得量 約 168 MB 相当の重み。画面の表示は 483 MB)"), ("li", "高精度 : large-v3-turbo(約 809M)。large-v3 のデコーダを 32 層から 4 層に減らした派生" "モデルで、開発元の OpenAI は、品質のわずかな低下と引き換えに大幅に高速化したと説明して" "います。"), ("li", "最高精度 : large-v3(約 1.55B)"), ("p", "翻訳 : Meta の NLLB-200 を CTranslate2 形式に変換したものを用います。標準は distilled 1.3B " "を int8 に量子化した版(約 1.4 GB)、高精度は 3.3B の float16 版(約 6.7 GB)です。" "NLLB-200 は 200 言語を対象とする翻訳モデルで、FLORES-200 で評価されています。"), ("p", "発話区間の検出 : faster-whisper に同梱される Silero VAD と、本アプリ独自のエネルギー" "ベースの検出器(第 6 節)を併用します。"), ("p", "音声合成 : Windows の SAPI5(OneCore の音声を含む)を pywin32 経由で用います。Windows に" "その言語の音声が無い場合は、sherpa-onnx の音声合成(日本語・インドネシア語・英語は " "Supertonic 3、中国語は Piper の xiao_ya)を別プロセスで実行します。"), ("p", "主要なライブラリ : ctranslate2、faster-whisper、tokenizers、numpy、sounddevice、" "huggingface-hub、pywin32、sherpa-onnx(内蔵音声合成を使う場合)、PyAV(faster-whisper が" "音声ファイルの復号に用いる)。"), ("p", "ライブラリの実際の版は、開始時に会話ログの「実行条件」に記録します。モデルの版は、取得元の" "リポジトリ名と、取得日時を記した .download-complete ファイルで特定できます。"), ("h2", "5. 主要なパラメータ"), ("li", "音声認識のビーム幅 : 復号中に保持する候補系列の数。2(速度優先)または 5(精度優先)を" "選べ、スライダーで 1〜10 に変更できます。faster-whisper の既定値は 5 です。"), ("li", "温度 : 0.0、0.2、0.4 の順に再復号します(圧縮率が 2.4 を超えた場合の再復号)。"), ("li", "非発話確率のしきい値 : 0.6。これ以上の区間は認識結果から除きます。"), ("li", "翻訳のビーム幅 : CPU では 2、GPU では 4 を既定とし、スライダーで 1〜8 に変更できます。"), ("li", "翻訳の最大出力長 : 256 トークン。"), ("li", "翻訳の n-gram 禁止長 : 空白で語を区切る言語(英語・インドネシア語)は 4、日本語・中国語は" "6。同じ断片が続く暴走を抑えるための設定です。"), ("li", "入力の目標実効値 : −24 dBFS(0 dBFS は実効値 1.0)。スライダーで −40〜−14 dBFS に変更" "できます。"), ("li", "読み上げ速度 : SAPI5 の Rate(−10〜+10)。内蔵音声では speed = 2^(Rate/10) の倍率に" "換算します(第 9 節)。"), ("h2", "6. 入力と前処理"), ("p", "マイクは 16 kHz・モノラル・16 bit 相当(float32)で開き、0.1 秒(1600 標本)ごとに処理" "します。音声ファイルは faster-whisper が PyAV で復号し、16 kHz モノラルに変換します。"), ("p", "入力レベルは、0.1 秒のブロックにハン窓を掛けて FFT を行い、200〜3800 Hz の帯域の電力を" "パーセバルの定理に基づいて積算して実効値を求めます(周波数の分解能は 10 Hz)。0 dBFS は" "実効値 1.0(フルスケールの方形波)と定義し、フルスケールの正弦波は約 −3 dBFS になります。" "この帯域は音声の第 1・第 2 フォルマントを含み、空調音などの低周波成分を除きます。"), ("p", "認識に与える前に、直流成分を除き、遮断周波数 80 Hz の零位相高域通過フィルタ" "(|H(f)| = f²/(f²+80²)。80 Hz で −6 dB、それ以下では 12 dB/oct で減衰)を掛け、実効値が" "目標値に近づく利得を掛けます。利得は標本ピークが 0.95 を超えない範囲、かつ 30 dB 以下と" "し、減衰は行いません。"), ("p", "標本ピークがフルスケールの 99% 以上に達した場合は、クリッピング(波形の飽和)の可能性が" "あるものとして画面に 1 度だけ案内します。"), ("h2", "7. 発話区間の検出"), ("p", "暗騒音のレベルは、直近 4 秒のブロックの 25 百分位で推定します。推定値は直ちに下降し、" "上昇は毎秒 12 dB に制限します(突発音でしきい値が上がり続けるのを防ぐため)。開始時は" "1 秒間の 50 百分位で初期値を定めます。下限は −75 dBFS です。"), ("p", "発話の開始は、帯域内実効値が「暗騒音の推定値 + 6 dB」(騒がしい環境では +12 dB)を超え、" "かつ絶対下限(−68 dBFS、騒がしい環境では −58 dBFS)以上である状態が、3 ブロック" "(騒がしい環境では 4 ブロック)連続したときに判定します。しきい値は低めに設定しており、" "雑音による誤検出は認識後の判定(第 8 節)で除きます。"), ("p", "発話の終了は、同じ値が継続判定のしきい値(開始のしきい値から 3 dB 低い値。騒がしい環境では" "6 dB 低い値)を下回る状態が、0.7 秒(騒がしい環境では 0.9 秒)続いたときに判定します。" "開始の 0.4 秒前(騒がしい環境では 0.5 秒前)から区間に含め、語頭の切断を防ぎます。"), ("p", "7 秒を超えた発話は、0.3 秒以上の短い無音(息継ぎ)、または継続判定が短時間途切れた時点で" "区切ります。暗騒音の推定値が発話中に上昇すると継続判定が途切れることがあり、区切りの理由を" "「息継ぎ」と記録した場合も、実際に無音があったことを意味しません。息継ぎが無いまま" "12 秒に達した場合は、直近 3 秒で最もレベルの低い位置(語と語の間である可能性が高い)で" "区切り、残りは次の区間の先頭に回します。"), ("p", "以上の長さ・しきい値は、スライダーと「使用環境」で変更できます。0.35 秒未満の区間、" "全体の実効値が継続判定の絶対下限を下回る区間、無音でないブロックが開始判定に要する数に" "満たない区間は、認識にかけずに棄却します。棄却した件数は「処理過程」タブに理由別に" "表示します。"), ("h2", "8. 音声認識"), ("p", "区間の音声を Whisper に与え、文字起こしを得ます。直前の認識結果を次の区間のプロンプトと" "して与えない設定(condition_on_previous_text = False)にし、誤りや繰り返しの連鎖を" "防ぎます。復号の前に Silero VAD(しきい値 0.35、最短発話 100 ms、最短無音 250 ms、" "前後の余白 250 ms)で非発話部分を除きます。"), ("p", "言語を自動判定する場合は、発話部分の先頭 30 秒で言語を識別し、候補言語のうち事後確率が" "最大のものを選びます。識別した言語で復号した結果の文字体系が、その言語の表記と矛盾する" "場合(例 : インドネシア語として復号した結果に仮名が含まれる)は、補正した言語で復号し" "直します。この補正はモデルの出力ではなく、本アプリの後処理です。"), ("p", "認識された区間のうち、非発話確率が 0.6 以上のもの、圧縮率が 2.4 以上のものは除きます。" "さらに、無音や雑音で生成されやすい定型句(「ご視聴ありがとうございました」など)、" "同じ断片の繰り返しだけの出力、文字体系が言語と矛盾する出力、4 文字以下の短文で非発話" "確率が 0.3 以上のもの、8 秒以内に同じ内容が再度現れたものを棄却します。"), ("h2", "9. 翻訳"), ("p", "原文を文単位に分割し、NLLB-200 の入力形式(原言語コード、トークン列、終端記号)を与え、" "出力の先頭に目的言語コードを固定して翻訳します。文の分割は、日本語・中国語の文末記号" "(。.!?…)と、英語などのピリオド・疑問符・感嘆符の直後の空白で行います。220 文字を" "超える文は読点・カンマで分けます。"), ("p", "訳文の品質は、モデル、文分割、ビーム幅、n-gram 禁止長の設定に依存します。NLLB-200 は" "1 文単位の翻訳を想定した研究用のモデルであり、文脈をまたぐ一貫性(代名詞の指示対象、" "話者の言い換えなど)は保証されません。"), ("h2", "10. 音声合成"), ("p", "訳文を、目的言語の Windows の音声(SAPI5、OneCore を含む)で読み上げます。Windows に" "その言語の音声が無い場合は、sherpa-onnx の音声合成を別プロセスで実行します。別プロセスに" "するのは、sherpa-onnx が同梱する onnxruntime.dll と、faster-whisper が Silero VAD に用いる" "onnxruntime の版が異なる場合に、同一プロセス内で衝突するのを避けるためです。"), ("p", "マイク入力は読み上げ中も処理を続けます。スピーカーから回り込んだ合成音声は、認識結果を" "直前に合成した文と文字列類似度(difflib の比率)で比較し、0.82 以上、または区間の 60% 以上" "が再生中で 0.45 以上の場合に破棄します。この判定は近似であり、短い相槌(4 文字未満)は" "対象外です。"), ("h2", "11. 「処理過程」タブの各項目"), ("li", "入力 : 区間の長さとブロック数、区間を確定した理由、区間の先頭と末尾の処理時刻、正規化前の" "標本ピーク、正規化の利得、正規化後の実効値、合成音声を再生していたブロックの割合。" "処理時刻は、PC がそのブロックを処理した時刻であり、マイクが音を取得した時刻ではありません。"), ("li", "区間検出 : 暗騒音の推定値、発話開始のしきい値、無音でなかったブロックの数と割合。"), ("li", "言語識別 : 候補言語、各候補の事後確率、採用した言語、文字体系による補正の有無。"), ("li", "音声認識 : モデル、計算型、ビーム幅、認識された区間ごとの開始・終了時刻、非発話確率、" "圧縮率、文字数。"), ("li", "棄却判定 : 定型句、文字体系の矛盾、短文雑音、重複、自己音声の各判定の結果。"), ("li", "翻訳 : 翻訳モデル、ビーム幅、n-gram 禁止長、文ごとの入力トークン数と訳文。"), ("li", "表示 : 認識の開始から表示までの時間(処理待ちを含まない)。"), ("h2", "12. 評価方法と指標"), ("p", "本アプリが画面に表示する指標は、処理時間、棄却した件数(理由別)、言語識別の事後確率、" "区間ごとの非発話確率と圧縮率です。音声認識の誤り率や翻訳品質そのものは、本アプリでは" "算出しません。"), ("p", "認識の精度を評価する場合は、正解の文字起こしを用意し、単語誤り率(WER)または文字誤り率" "(CER)を算出します。日本語・中国語のように語の区切りが明示されない言語では、文字単位の" "CER が一般的です。翻訳の品質は、BLEU、chrF、COMET などの指標、または人手による評価で" "測ります。指標の値は評価データに依存するため、異なるデータセットの値を直接比較することは" "できません。"), ("p", "言語識別の事後確率は、Whisper が対応する全言語のうち採用した言語に割り当てた確率で、" "較正された値ではなく、認識結果の正しさを示すものでもありません。"), ("h2", "13. 結果を再現するための条件"), ("p", "同じ結果を得るには、次の条件を揃える必要があります。"), ("li", "同じ音声(同じファイル、または同じマイク・同じ位置での発話)。本アプリはマイクの音声を" "保存しないため、マイク入力の再現には同じ音声を録音して音声ファイルとして与えます。"), ("li", "同じモデル(取得元のリポジトリ名が一致すること)と、同じ計算型(float16 / int8 など)。" "量子化の違いは出力を変えます。"), ("li", "同じパラメータ(ビーム幅、温度の列、しきい値、前処理の設定)。実行条件は会話ログの" "先頭に記録されます。"), ("li", "同じライブラリの版。版によって既定値や実装が変わる可能性があります。"), ("p", "温度が 0 より大きい再復号ではサンプリングが行われ、乱数種は指定していません。そのため、" "圧縮率がしきい値を超えて再復号が行われた発話は、同一の入力でも結果が変わり得ます。" "ビーム探索のみによる復号(温度 0)は決定的です。"), ("h2", "14. 限界と不確実性"), ("li", "NLLB-200 は 1 文単位の翻訳を想定した研究用のモデルで、実運用向けには公開されていません。" "認証翻訳、医療・法律などの専門文書、重要な判断には、出力をそのまま用いないでください。"), ("li", "文脈をまたぐ一貫性は保証されません。代名詞、敬称、専門用語の訳語は発話ごとに揺れます。"), ("li", "英語の略語(Dr. など)の直後でも文を分割するため、そのような文は複数の文として翻訳され、" "訳文の語順や文体が変わる場合があります。"), ("li", "話者が重なって話した場合、遠くの話者の声、反響の強い部屋では、区間の検出と認識の精度が" "低下します。マイクの位置と利得の調整が必要です。"), ("li", "言語の自動判定は発話の先頭部分に基づくため、短い発話や混成した発話では誤ることが" "あります。会話モードでは、誤判定すると訳文の言語が入れ替わります。"), ("li", "無音や雑音の区間で、Whisper が存在しない文を生成することがあります。本アプリは定型句・" "繰り返し・文字体系・非発話確率・短文の判定でこれを除きますが、完全には防げません。"), ("li", "自己音声の判定は文字列の類似度に基づく近似です。読み上げと発話が重なった場合、実際の" "発話を破棄することもあります。"), ("li", "CPU では、大きなモデルほど 1 発話あたりの処理時間が長くなります。処理が入力に追いつかない" "場合、発話は破棄せず順に処理するため、表示が遅れます。"), ("li", "停止を押した時点で処理中だった発話は、区間の検出までで破棄され、認識されません。"), ("li", "「相手向け表示」の最短表示時間は、文字数を読字速度の目安(日本語 4、中国語 9、" "インドネシア語 17、英語 20 文字/秒)で割り、2〜7 秒に収めた値です。日本語の 4 文字/秒と" "英語の 20 文字/秒は、Netflix の字幕制作ガイドラインに示された成人向けの上限に合わせて" "います。中国語とインドネシア語の値は本アプリの設定値です。"), ("li", "マイクの入力レベルが低い場合や、クリッピングしている場合は、画面に 1 度だけ案内します。" "案内が出た場合は、マイクの位置と入力音量を調整してください。"), ("h2", "15. ライセンスとデータの扱い"), ("li", "Whisper の重み : MIT ライセンス(OpenAI)。faster-whisper、CTranslate2、Silero VAD は " "MIT ライセンスです。"), ("li", "NLLB-200 の重み : CC-BY-NC 4.0(Meta)。非営利の利用に限られます。"), ("li", "sherpa-onnx : Apache-2.0。内蔵音声のモデル(Supertonic 3、Piper xiao_ya)の利用条件は、" "それぞれの配布ページの記載に従います。"), ("li", "入力した音声とテキストは、この PC の外へ送信しません。会話ログと設定は、このアプリの" "ファイルと同じフォルダに保存されます。"), ("p", "本アプリは、上記のモデルとライブラリを改変せずに用います。モデルの取得元と取得日時は、" "models フォルダ内の .download-complete に記録されます。"), ) # ---------------------------------------------------------------- 画面文言(英・日・尼・中) UI_TEXT = {key: by_lang(*texts) for key, texts in { "title": ("Speech Translator", "音声翻訳", "Penerjemah Suara", "语音翻译"), "tab_run": ("Run", "実行", "Jalankan", "运行"), "tab_trace": ("Process", "処理過程", "Proses", "处理过程"), "tab_help": ("Help", "ヘルプ", "Bantuan", "帮助"), "direction": ("Direction:", "翻訳方向:", "Arah:", "翻译方向:"), "swap": ("⇄ Swap", "⇄ 入れ替え", "⇄ Tukar", "⇄ 互换"), "source": ("Audio input:", "音声の入力元:", "Masukan audio:", "音频输入:"), "src_mic": ("Microphone", "マイク", "Mikrofon", "麦克风"), "src_file": ("Audio file", "音声ファイル", "File audio", "音频文件"), "choose_file": ("Select file…", "ファイルを選択…", "Pilih file…", "选择文件…"), "nofile": ("No file selected.", "ファイルが選択されていません。", "Belum ada file yang dipilih.", "未选择文件。"), "mic": ("Microphone:", "マイク:", "Mikrofon:", "麦克风:"), "nomic": ("No input device that can be opened at 16 kHz mono was found.", "16 kHz・モノラルで使用できる入力デバイスが見つかりません。", "Tidak ditemukan perangkat masukan yang dapat dibuka pada 16 kHz mono.", "未找到可以 16 kHz 单声道打开的输入设备。"), "model": ("Speech recognition model:", "音声認識モデル:", "Model pengenalan ucapan:", "语音识别模型:"), "model_std": ("Standard (small)", "標準 (small)", "Standar (small)", "标准 (small)"), "model_high": ("High accuracy (large-v3-turbo)", "高精度 (large-v3-turbo)", "Akurasi tinggi (large-v3-turbo)", "高精度 (large-v3-turbo)"), "model_max": ("Highest accuracy (large-v3)", "最高精度 (large-v3)", "Akurasi tertinggi (large-v3)", "最高精度 (large-v3)"), "modelinfo": ("About {params} parameters; download about {size}.", "パラメータ数は約 {params}、取得量は約 {size} です。", "Sekitar {params} parameter; unduhan sekitar {size}.", "参数量约 {params},下载量约 {size}。"), "turbonote": ("large-v3-turbo has a 4-layer decoder (large-v3 has 32 layers).", "large-v3-turbo はデコーダが 4 層です(large-v3 は 32 層)。", "large-v3-turbo memakai dekoder 4 lapisan (large-v3: 32 lapisan).", "large-v3-turbo 的解码器为 4 层(large-v3 为 32 层)。"), "cpuheavy": ("On CPU this model takes several seconds or more per utterance.", "CPU では 1 発話に数秒以上かかることがあります。", "Di CPU model ini perlu beberapa detik atau lebih per ucapan.", "在 CPU 上每句可能需要数秒以上。"), "decode": ("Decoding:", "復号:", "Dekode:", "解码:"), "decode_fast": ("Speed first (beam 2)", "速度優先(ビーム幅 2)", "Utamakan kecepatan (beam 2)", "速度优先(束宽 2)"), "decode_acc": ("Accuracy first (beam 5)", "精度優先(ビーム幅 5)", "Utamakan akurasi (beam 5)", "精度优先(束宽 5)"), "decodenote": ("Beam width = number of candidate sequences kept while decoding " "(faster-whisper default 5). See the Help tab for details.", "ビーム幅は復号中に保持する候補系列の数です(faster-whisper の既定値は 5)。" "詳細は「ヘルプ」タブにあります。", "Lebar beam = jumlah kandidat urutan yang dipertahankan saat dekode " "(bawaan faster-whisper 5). Rincian ada di tab Bantuan.", "束宽为解码时保留的候选序列数(faster-whisper 默认 5)。详见“帮助”标签。"), "mtmodel": ("Translation model:", "翻訳モデル:", "Model terjemahan:", "翻译模型:"), "mt_std": ("Standard (NLLB-200 distilled 1.3B)", "標準 (NLLB-200 distilled 1.3B)", "Standar (NLLB-200 distilled 1.3B)", "标准 (NLLB-200 distilled 1.3B)"), "mt_large": ("High accuracy (NLLB-200 3.3B, GPU)", "高精度 (NLLB-200 3.3B、GPU 向け)", "Akurasi tinggi (NLLB-200 3.3B, GPU)", "高精度(NLLB-200 3.3B,适用于 GPU)"), "mtinfo": ("About {params} parameters; download about {size} (first use only).", "パラメータ数は約 {params}、取得量は約 {size} です(初回のみ)。", "Sekitar {params} parameter; unduhan sekitar {size} (hanya saat pertama).", "参数量约 {params},下载量约 {size}(仅首次)。"), "mtlargenote": ("float16 on GPU; needs about 8 GB of GPU memory in addition to the " "recognition model.", "GPU では float16 で実行し、認識モデルとは別に約 8 GB の GPU メモリを使用します。", "float16 di GPU; perlu sekitar 8 GB memori GPU di luar model pengenalan.", "在 GPU 上以 float16 运行,除识别模型外还需约 8 GB 显存。"), "mtcpuheavy": ("On CPU this model loads slowly and takes several seconds or more per sentence.", "CPU では読み込みが遅く、1 文に数秒以上かかることがあります。", "Di CPU model ini lambat dimuat dan perlu beberapa detik per kalimat.", "在 CPU 上加载较慢,每句可能需要数秒以上。"), "device": ("Compute device:", "実行デバイス:", "Perangkat komputasi:", "运行设备:"), "dev_cpu": ("CPU",) * 4, "dev_gpu": ("GPU (CUDA)",) * 4, "nocudalib": ("(A CUDA-capable GPU was detected, but cuBLAS for CUDA 12 or cuDNN could not " "be loaded, so GPU execution is unavailable.)", "(CUDA 対応 GPU は検出されましたが、CUDA 12 用の cuBLAS または cuDNN を読み込めない" "ため、GPU では実行できません)", "(GPU dengan CUDA terdeteksi, tetapi cuBLAS untuk CUDA 12 atau cuDNN tidak dapat " "dimuat, sehingga eksekusi GPU tidak tersedia.)", "(检测到支持 CUDA 的 GPU,但无法加载 CUDA 12 版 cuBLAS 或 cuDNN,因此不能在 GPU 上运行)"), "nogpu": ("(no CUDA-capable GPU detected)", "(CUDA 対応 GPU は検出されませんでした)", "(GPU dengan CUDA tidak terdeteksi)", "(未检测到支持 CUDA 的 GPU)"), "noiseenv": ("Environment:", "使用環境:", "Lingkungan:", "使用环境:"), "quietmode": ("Quiet (indoors)", "静か(屋内)", "Tenang (dalam ruangan)", "安静(室内)"), "noisymode": ("Noisy (restaurant / outdoors)", "騒がしい(飲食店・屋外)", "Bising (restoran / luar ruangan)", "嘈杂(餐厅/户外)"), "params": ("Live parameters (applied from the next utterance)", "リアルタイム調整(次の発話から反映)", "Parameter langsung (berlaku mulai ucapan berikutnya)", "实时调整(从下一句起生效)"), "p_gain": ("Input level target", "入力の目標実効値", "Target level masukan", "输入目标电平"), "p_onset": ("Speech-onset SNR", "発話開始の SN 比", "SNR awal ucapan", "语音起始信噪比"), "p_silence": ("Silence to end a segment", "無音とみなす継続時間", "Diam untuk mengakhiri segmen", "判定句末的静音时长"), "p_maxlen": ("Maximum segment length", "最大発話長", "Panjang segmen maksimum", "最大语音段长度"), "p_asrbeam": ("Recognition beam width", "認識のビーム幅", "Lebar beam pengenalan", "识别束宽"), "p_mtbeam": ("Translation beam width", "翻訳のビーム幅", "Lebar beam terjemahan", "翻译束宽"), "p_rate": ("Speech rate (SAPI5 Rate)", "読み上げ速度(SAPI5 Rate)", "Kecepatan bicara (Rate)", "朗读速度(SAPI5 Rate)"), "paramsnote": ("Changes are read from the next block (onset, silence, maximum length), the next " "utterance (input level, speech rate) and the next decode (beam widths).", "変更は、区間検出(開始しきい値・無音時間・最大発話長)は次のブロックから、" "入力レベルと読み上げ速度は次の発話から、ビーム幅は次の復号から反映されます。", "Perubahan dibaca mulai blok berikutnya (ambang, diam, panjang maksimum), ucapan " "berikutnya (level, kecepatan) dan dekode berikutnya (lebar beam).", "修改自下一块(起始阈值、静音、最大长度)、下一句(输入电平、朗读速度)与下次解码" "(束宽)起生效。"), "start": ("▶ Start", "▶ 開始", "▶ Mulai", "▶ 开始"), "stop": ("■ Stop", "■ 停止", "■ Berhenti", "■ 停止"), "clear": ("Clear", "表示を消去", "Hapus", "清除"), "openlog": ("Open log", "ログを開く", "Buka log", "打开日志"), "copy": ("Copy latest result", "最新の結果をコピー", "Salin hasil terbaru", "复制最新结果"), "copied": ("Copied the latest result (the translation, or the transcript in transcription-only " "mode) to the clipboard.", "最新の結果(訳文。文字起こしのみの場合は認識結果)をクリップボードにコピーしました。", "Hasil terbaru disalin ke papan klip.", "已将最新结果复制到剪贴板。"), "notext": ("There is no result yet.", "まだ結果がありません。", "Belum ada hasil.", "还没有结果。"), "tts": ("Read translations aloud", "訳文を音声合成で読み上げる", "Bacakan terjemahan", "用语音合成朗读译文"), "resultswin": ("Results window", "結果ウィンドウ", "Jendela hasil", "结果窗口"), "results": ("Results (recognized text / translation)", "認識結果と訳文", "Hasil (teks pengenalan / terjemahan)", "识别与翻译结果"), "partner": ("Partner view", "相手向け表示", "Tampilan lawan bicara", "对方视图"), "miclevel": ("Input level:", "入力レベル:", "Level masukan:", "输入电平:"), "meterlegend": ("Bar: band-limited RMS (200–3800 Hz) per {block:.1f} s. Dotted: estimated " "background noise. Orange: speech-onset threshold (noise + {margin:.0f} dB or " "the absolute floor {floor:.0f} dBFS, whichever is higher). Red: possible " "clipping. Definitions are in the Help tab.", "バー: 200–3800 Hz に帯域制限した実効値({block:.1f} 秒ごと)。点線: 暗騒音の推定値。" "橙線: 発話開始のしきい値(暗騒音+{margin:.0f} dB と絶対下限 {floor:.0f} dBFS の" "高い方)。赤: クリッピングの可能性。定義は「ヘルプ」タブにあります。", "Batang: RMS pita 200–3800 Hz tiap {block:.1f} detik. Putus-putus: perkiraan " "derau latar. Oranye: ambang awal ucapan (derau + {margin:.0f} dB atau batas " "{floor:.0f} dBFS, yang lebih tinggi). Merah: kemungkinan clipping. Definisi di " "tab Bantuan.", "电平条:200–3800 Hz 带限 RMS(每 {block:.1f} 秒)。虚线:背景噪声估计。橙线:语音" "起始阈值(噪声+{margin:.0f} dB 与绝对下限 {floor:.0f} dBFS 中的较高者)。红色:可能" "削波。定义见“帮助”标签。"), "speaking": ("Speech detected", "発話を検出中", "Ucapan terdeteksi", "检测到语音"), "waiting": ("Ready (press Start)", "待機中(「開始」を押してください)", "Siaga (tekan Mulai)", "待机(请按开始)"), "calibrating": ("Measuring background noise for about {sec:.0f} s… please do not speak.", "暗騒音レベルを測定しています(約 {sec:.0f} 秒)。話さずにお待ちください。", "Mengukur kebisingan latar sekitar {sec:.0f} detik… mohon jangan berbicara.", "正在测量背景噪声(约 {sec:.0f} 秒)……请勿说话。"), "listening": ("Listening… please speak.", "音声入力を待っています。マイクに向かって話してください。", "Mendengarkan… silakan bicara.", "正在等待语音输入……请对着麦克风说话。"), "idle": ("(no speech detected for {sec} s; still listening)", "({sec} 秒間、発話が検出されていません。入力の待機を続けています)", "(tidak ada ucapan terdeteksi selama {sec} detik; masih mendengarkan)", "(已 {sec} 秒未检测到语音,仍在等待输入)"), "recognizing": ("Recognizing speech…", "音声を認識しています…", "Mengenali ucapan…", "正在识别语音……"), "translating": ("Translating…", "翻訳しています…", "Menerjemahkan…", "正在翻译……"), "fileproc": ("Processing audio file…", "音声ファイルを処理しています…", "Memproses file audio…", "正在处理音频文件……"), "batchnote": ("The audio file is split by voice activity detection into speech segments, which " "are processed together by batched inference within the model's 30 s input " "window; results may therefore differ from sequential processing. In " "auto-detect mode the language is identified once from the first 30 s of speech " "and the whole file is processed as that language. The progress bar shows the end " "time of the last processed segment as a fraction of the file length.", "音声ファイルは、音声区間検出(Silero VAD)で発話区間を抽出し、モデルの入力長" "(30 秒)に収まるようにまとめて一括推論で処理します。そのため、逐次処理とは" "認識結果が異なる場合があります。言語を自動判定する場合は、発話部分の先頭 30 秒で" "1 回だけ識別し、ファイル全体をその言語として処理します。進捗バーは、処理を終えた" "区間の終了時刻が音声全体の長さに占める割合を示します。", "File audio dipecah dengan deteksi aktivitas suara menjadi segmen ucapan, lalu " "diproses bersama dengan inferensi batch dalam jendela masukan 30 detik; hasilnya " "dapat berbeda dari pemrosesan berurutan. Pada mode deteksi otomatis, bahasa " "diidentifikasi sekali dari 30 detik pertama ucapan dan seluruh file diproses " "sebagai bahasa tersebut. Bilah kemajuan menunjukkan waktu akhir segmen terakhir " "yang selesai diproses sebagai bagian dari panjang file.", "音频文件经语音活动检测(Silero VAD)提取语音段,并在模型 30 秒输入窗口内以批量" "推理一并处理,因此识别结果可能与顺序处理不同。自动识别语种时,仅根据语音部分的" "前 30 秒识别一次语种,并将整个文件按该语种处理。进度条表示已处理区段的结束时间" "占文件总时长的比例。"), "filedone": ("Finished processing the file.", "ファイルの処理が完了しました。", "Selesai memproses file.", "文件处理完成。"), "stopped": ("Stopped.", "停止しました。", "Dihentikan.", "已停止。"), "downloading": ("Downloading a model (only the first time it is used)…", "モデルをダウンロードしています(各モデルを初めて使うときのみ)…", "Mengunduh model (hanya saat pertama kali digunakan)…", "正在下载模型(仅在首次使用该模型时)……"), "loading": ("Loading models…", "モデルを読み込んでいます…", "Memuat model…", "正在加载模型……"), "warming": ("Warming up (running a first inference)…", "ウォームアップ中(初回の推論を実行しています)…", "Pemanasan (menjalankan inferensi pertama)…", "预热中(执行首次推理)……"), "audiofile": ("Audio file", "音声ファイル", "File audio", "音频文件"), "allfiles": ("All files", "すべてのファイル", "Semua file", "所有文件"), "lowmic": ("The input level is low, so a large gain (+{gain:.0f} dB) is applied before " "recognition. Speaking closer to the microphone raises the signal-to-noise ratio.", "入力レベルが低いため、認識の前に大きな利得(+{gain:.0f} dB)を加えています。" "マイクに近づいて話すと SN 比が上がります。", "Level masukan rendah sehingga penguatan besar (+{gain:.0f} dB) diterapkan.", "输入电平偏低,识别前施加了较大增益(+{gain:.0f} dB)。靠近麦克风说话可提高信噪比。"), "clipping": ("The sample peak reached {peak:.1f} dBFS, so clipping (waveform saturation) may " "have occurred. Lower the microphone input volume.", "標本ピークが {peak:.1f} dBFS に達しており、クリッピング(波形の飽和)が生じた" "可能性があります。マイクの入力音量を下げてください。", "Puncak sampel mencapai {peak:.1f} dBFS; mungkin terjadi clipping.", "采样峰值达到 {peak:.1f} dBFS,可能已发生削波。请调低麦克风输入音量。"), "ignored": ("(discarded as noise, misrecognition or duplicates: {n} in total)", "(雑音・誤認識・重複と判定して破棄した発話: 累計 {n} 件)", "(dibuang sebagai derau, salah pengenalan, atau duplikat: total {n})", "(判定为噪声、误识别或重复而丢弃的语句:累计 {n} 条)"), "echodrop": ("(discarded as this app's synthesized speech: {n} in total)", "(本アプリの合成音声と判定して破棄: 累計 {n} 件)", "(dibuang karena suara sintesis aplikasi ini: total {n})", "(判定为本程序的合成语音而丢弃:累计 {n} 条)"), "nospeech": ("(no speech found in the segment; nothing was recognized)", "(区間内に発話が見つからず、認識結果はありません)", "(tidak ada ucapan dalam segmen; tidak ada hasil pengenalan)", "(该段内未发现语音,没有识别结果)"), "pending": ("(utterances waiting to be processed: {n})", "(処理待ちの発話: {n} 件)", "(ucapan menunggu diproses: {n})", "(待处理语句:{n} 条)"), "behind": ("Recognition is not keeping up with the input. Nothing is discarded and utterances " "are processed in order, but a smaller model or a narrower beam reduces the delay.", "音声認識の処理が入力に追いついていません。発話は破棄せず順に処理しますが、" "より小さいモデルか狭いビーム幅を選ぶと遅れが小さくなります。", "Pengenalan tidak mengimbangi masukan. Tidak ada yang dibuang dan ucapan diproses " "berurutan, tetapi model lebih kecil atau beam lebih sempit mengurangi keterlambatan.", "语音识别跟不上输入。语句不会被丢弃并按顺序处理,但选择更小的模型或更窄的束宽可减少延迟。"), "miclost": ("The microphone connection was lost. Check the device and press Start again.", "マイクの接続が失われました。デバイスを確認し、もう一度「開始」を押してください。", "Koneksi mikrofon terputus. Periksa perangkat lalu tekan Mulai lagi.", "麦克风连接已断开。请检查设备后重新按下开始。"), "aborted": ("Processing was stopped because an error occurred:", "エラーが発生したため処理を停止しました:", "Pemrosesan dihentikan karena terjadi galat:", "由于发生错误,处理已停止:"), "oomhint": ("(A GPU-related error occurred. If GPU memory is insufficient, select CPU or a " "smaller model.)", "(GPU に関するエラーです。GPU のメモリが不足している場合は、実行デバイスを CPU にするか、" "より小さいモデルを選んでください。)", "(Terjadi galat terkait GPU. Bila memori GPU kurang, pilih CPU atau model lebih kecil.)", "(发生了与 GPU 相关的错误。若显存不足,请改用 CPU 或更小的模型。)"), "langid": ("language-ID posterior", "言語識別の事後確率", "probabilitas posterior bahasa", "语种识别后验概率"), "langidnote": ("The language-ID posterior is the probability Whisper assigned to the adopted " "language; it is not calibrated and does not indicate whether the text is correct.", "「言語識別の事後確率」は、Whisper が採用した言語に割り当てた確率です。較正された値では" "なく、認識結果の正しさを示すものでもありません。", "Probabilitas posterior bahasa adalah nilai yang diberikan Whisper kepada bahasa " "yang dipakai; tidak dikalibrasi dan tidak menunjukkan kebenaran teks.", "“语种识别后验概率”是 Whisper 赋予所采用语种的概率。该值未经校准,也不表示文本正确。"), "elapsed": ("(processing time {sec:.1f} s from recognition start to display, excluding queue " "wait)", "(処理時間 {sec:.1f} 秒: 認識開始から表示まで。処理待ちを除く)", "(waktu proses {sec:.1f} detik dari awal pengenalan hingga tampil, tanpa antrean)", "(处理耗时 {sec:.1f} 秒:自识别开始至显示,不含排队等待)"), "zoomhint": ("Drag the window edge to resize. Ctrl + mouse wheel changes both text sizes; the " "number after × is the scale factor.", "ウィンドウの端をドラッグすると大きさを変えられます。Ctrl+マウスホイールで両方の文字" "サイズを変更できます。「×」の後の数値は基準サイズに対する倍率です。", "Tarik tepi jendela untuk mengubah ukuran. Ctrl + roda tetikus mengubah kedua ukuran " "teks; angka setelah × adalah faktor skala.", "拖动窗口边缘可调整大小。Ctrl+鼠标滚轮可同时调整两种字号。“×”后的数值为倍率。"), "fullhint": ("F11 or double-click: full screen / Esc: exit full screen", "F11 またはダブルクリックで全画面表示、Esc で解除します。", "F11 atau klik ganda: layar penuh / Esc: keluar dari layar penuh", "F11 或双击:全屏 / Esc:退出全屏"), "keyhint": ("F5: start / stop", "F5 キーで開始・停止を切り替えます。", "F5: mulai / berhenti", "F5:开始 / 停止"), "srcfont": ("Recognized-text size:", "認識結果(原文)の文字サイズ:", "Ukuran teks pengenalan:", "识别结果(原文)字号:"), "dstfont": ("Translation-text size:", "訳文の文字サイズ:", "Ukuran teks terjemahan:", "翻译结果字号:"), "voices": ("Synthesis voices:", "使用する合成音声:", "Suara sintesis:", "合成语音:"), "ttsnote": ("A language without a Windows voice is read aloud with the built-in synthesis " "(sherpa-onnx). Its model is downloaded the first time it is needed " "(Supertonic 3 about 129 MB, Piper about 60 MB).", "Windows に音声が無い言語は、内蔵の音声合成(sherpa-onnx)で読み上げます。音声モデルは" "初めて必要になったときに取得します(Supertonic 3 は約 129 MB、Piper は約 60 MB)。", "Bahasa tanpa suara Windows dibacakan dengan sintesis bawaan (sherpa-onnx). Modelnya " "diunduh saat pertama diperlukan (Supertonic 3 sekitar 129 MB, Piper sekitar 60 MB).", "没有 Windows 语音的语言使用内置语音合成(sherpa-onnx)朗读;模型在首次需要时下载" "(Supertonic 3 约 129 MB,Piper 约 60 MB)。"), "ttsabsent": ("The built-in voice {model} (about {size}) is downloaded when reading aloud starts.", "内蔵音声 {model}(約 {size})は、読み上げを始めるときに取得します。", "Suara bawaan {model} (sekitar {size}) diunduh saat pembacaan dimulai.", "内置语音 {model}(约 {size})将在开始朗读时下载。"), "echonote": ("The microphone keeps being processed while synthesized speech plays. If it picks " "up this app's own voice, the recognized text is compared with the text just " "synthesized and discarded when similar, so neither headsets nor loudspeakers " "need a setting.", "音声合成の再生中もマイク入力を処理します。スピーカーから出た合成音声をマイクが拾った" "場合は、その認識結果を直前に合成した文と比較し、類似していれば破棄するため、" "ヘッドセットとスピーカーのどちらでも設定の変更は不要です。", "Mikrofon tetap diproses saat suara sintesis diputar. Bila menangkap suara aplikasi " "ini, teks hasil pengenalan dibandingkan dengan teks yang baru disintesis dan " "dibuang bila mirip.", "播放合成语音期间仍处理麦克风输入。若拾取到本程序自身的语音,会将识别文本与刚合成的" "文本比较,相似则丢弃,因此耳机与扬声器均无需更改设置。"), "autolog": ("The conversation log is saved automatically to:", "会話ログの自動保存先:", "Log percakapan disimpan otomatis ke:", "对话记录自动保存至:"), "notice": ("Recognition, translation and synthesis run only on this PC (the network is used " "only to download each model the first time). The translation model (NLLB-200, " "CC-BY-NC 4.0) is a research model for single-sentence translation; do not use its " "output as-is for certified translations, specialized documents or important " "decisions.", "音声認識・翻訳・音声合成はこの PC 上だけで実行されます(通信するのは、各モデルを初めて" "使うときの取得時のみです)。翻訳モデル(NLLB-200、CC-BY-NC 4.0)は 1 文単位の翻訳を" "想定した研究用のモデルです。認証翻訳、専門文書、重要な判断には、出力をそのまま用い" "ないでください。", "Pengenalan, penerjemahan, dan sintesis berjalan hanya di PC ini (jaringan hanya untuk " "mengunduh model saat pertama dipakai). Model penerjemah (NLLB-200, CC-BY-NC 4.0) " "adalah model riset untuk terjemahan per kalimat.", "语音识别、翻译与语音合成仅在本机运行(仅在首次使用各模型时联网下载)。翻译模型" "(NLLB-200,CC-BY-NC 4.0)是面向单句翻译的研究用模型;请勿将其输出直接用于认证翻译、" "专业文本或重要决策。"), "viewmode": ("Window:", "表示:", "Jendela:", "窗口:"), "view_laptop": ("Laptop (fits 768 px)", "ノート PC(768 画素に収める)", "Laptop (muat 768 px)", "笔记本(适配 768 像素)"), "view_full": ("Full screen", "全画面", "Layar penuh", "全屏"), "view_normal": ("Default size", "既定の大きさ", "Ukuran bawaan", "默认大小"), "trace_list": ("Utterances", "発話の一覧", "Daftar ucapan", "语句列表"), "trace_stage": ("Stage", "段階", "Tahap", "阶段"), "trace_item": ("Item", "項目", "Butir", "项目"), "trace_value": ("Value", "値", "Nilai", "值"), "trace_follow": ("Follow the latest", "最新に追従", "Ikuti terbaru", "跟随最新"), "trace_save": ("Save as TSV", "TSV で保存", "Simpan sebagai TSV", "保存为 TSV"), "trace_saved": ("Saved the calculation trace to:", "算出過程を保存しました:", "Jejak perhitungan disimpan ke:", "已将计算过程保存至:"), "trace_none": ("No utterance has been processed yet.", "まだ発話を処理していません。", "Belum ada ucapan yang diproses.", "尚未处理任何语句。"), "trace_japanese": ("The entries in this tab and in the Help tab are written in Japanese.", "このタブと「ヘルプ」タブの記載は日本語です。", "Isi tab ini dan tab Bantuan ditulis dalam bahasa Jepang.", "本标签与“帮助”标签的内容为日文。"), "trace_summary": ("Confirmed {ok} / discarded by the detector {short} (too short) {quiet} " "(too quiet) {inactive} (too few active blocks) / discarded after recognition " "{ignored} / own synthesized speech {echo} / no speech {nospeech}", "確定した区間 {ok} 件/検出器で棄却 {short} 件(短すぎる){quiet} 件(静かすぎる)" "{inactive} 件(無音でないブロックが不足)/認識後に棄却 {ignored} 件/" "自己音声 {echo} 件/発話なし {nospeech} 件", "Segmen dikonfirmasi {ok} / dibuang detektor {short} {quiet} {inactive} / " "dibuang setelah pengenalan {ignored} / suara sendiri {echo} / tanpa ucapan " "{nospeech}", "已确定语音段 {ok}/检测器丢弃 {short}(过短){quiet}(过静){inactive}" "(有效块不足)/识别后丢弃 {ignored}/自身语音 {echo}/无语音 {nospeech}"), "help_hint": ("Operation, models, parameters, limitations and licences: see the Help tab.", "操作手順・モデル・パラメータ・限界・ライセンスは「ヘルプ」タブにあります。", "Prosedur, model, parameter, batasan, dan lisensi: lihat tab Bantuan.", "操作步骤、模型、参数、局限与许可:见“帮助”标签。"), }.items()} FONT_SCALE_STEPS = (1.0, 1.2, 1.5, 2.0, 2.5, 3.0) BASE_FONT_SIZE = {"src": 11, "dst": 14} FONT_BOLD = {"src": False, "dst": True} MAX_RECORDS = 4000 SMALL_FONT = ("Meiryo UI", 8) MAX_TRACES = 300 # 相手向け表示で、1 件の訳文を次の訳文に置き換えるまでの最短の表示時間。 # 訳文の文字数(空白を除く)を読字速度で割った時間とし、下限と上限の範囲に収める。 # 日本語 4・英語 20 文字/秒は、Netflix の字幕制作ガイドライン(成人向けの上限)に合わせている。 # 中国語 9・インドネシア語 17 文字/秒は本アプリの設定値であり、外部の規格に基づくものではない。 PARTNER_READ_CPS = {"ja": 4.0, "zh": 9.0, "id": 17.0, "en": 20.0} PARTNER_MIN_HOLD_SEC = 2.0 PARTNER_MAX_HOLD_SEC = 7.0 PARTNER_MERGE_MAX = 3 # 表示待ちの訳文をまとめて表示する件数の上限 PARTNER_MIN_FONT = 24 PARTNER_MAX_FONT = 120 PARTNER_SRC_MAX_LINES = 2 # 原文は最大この行数とし、訳文の表示領域を確保する PARTNER_PAD_X = 60 # 左右の余白(pack の padx 24×2)とラベルの枠・内側余白 PARTNER_PAD_Y = 48 # 上下の余白(pack の pady の合計) PARTNER_LABEL_EXTRA = 8 # ラベル 1 つあたりの枠・内側余白(上下の合計) PARTNER_FIT_DELAY_MS = 60 # ウィンドウの大きさを変える操作中は、止まってから計算し直す # ---------------------------------------------------------------- 算出過程の記録 class Trace: """1 発話の算出過程。(段階, 項目, 値) の列を保持する。worker スレッドが作り、UI スレッドが読む。""" def __init__(self, index, when): self.index = index self.when = when self.rows = [] self.head = "" def add(self, stage, item, value): self.rows.append((stage, item, str(value))) def label(self): return f"#{self.index} {self.when} {self.head[:28]}" def short(text, limit): """画面に出す値を短くする(長い場合は末尾を省く)。""" text = " ".join(str(text).split()) return text if len(text) <= limit else text[:limit - 1] + "…" # ---------------------------------------------------------------- アプリケーション class TranslatorApp: def __init__(self, root): self.root = root # 予期しない失敗は一か所で受け、停止して操作できる状態へ戻す threading.excepthook = self._thread_exception root.report_callback_exception = self._tk_exception self.alive = True self.running = False self.busy = False self.session = 0 settings, notice = load_settings() self.settings = settings self.params = Params() self.params.restore(settings.get("params")) self.engine = Engine(self.params) self.stream = None self.source_mode = tk.StringVar(value=settings.get("source", "mic")) self.selected_file = settings.get("file", "") self.audio_queue = queue.Queue() self.utterance_queue = queue.Queue() self.noise_profile = self._valid(settings.get("noise"), NOISE_PROFILES, DEFAULT_NOISE_PROFILE) self.segmenter = Segmenter(self.noise_profile, self.params) self.records = [] # 結果ウィンドウの内容 [(文, タグ)]。UI スレッドでのみ扱う self.direction = DEFAULT_DIRECTION self.input_mode = "mic" # 動作中の入力元 self.disp_langs = ["en"] self.status_key, self.status_extra, self.status_values = "waiting", "", {} self.last_translation = "" self.log_file = None self.log_path = None self.level_db = self.noise_db = self.thresh_db = self.shown_db = METER_MIN_DB self.clip_time = float("-inf") # 入力の標本ピーク値が CLIP_PEAK 以上になった最後の時刻 self.speaking = False self.low_mic_notified = self.clip_notified = self.behind_notified = False self.ignored = self.echoes = self.nospeech = 0 self.last_key, self.last_key_time = "", 0.0 self.spoken = collections.deque(maxlen=SPOKEN_HISTORY) # 直前に合成した文 self.devices = usable_input_devices() self._mic_label_to_index = {name: index for index, name in self.devices} self.model_key = self._valid(settings.get("model"), MODEL_KEYS, "standard") self.mt_key = self._valid(settings.get("mt"), MT_TEXT_KEY, "standard") self._texts = [] # [(ウィジェット, 文言キー)]。表示言語の変更時に一括更新する self.run_text = self.win_text = self.results_win = None fonts = settings["fonts"] if isinstance(settings.get("fonts"), dict) else {} self.font_idx = {tag: tk.IntVar(value=self._valid(fonts.get(tag), range(len(FONT_SCALE_STEPS)), 0)) for tag in ("src", "dst")} self.font_readout = {"src": None, "dst": None} self.partner_win = self.partner_src_label = self.partner_dst_label = None self.partner_hint_label = None self.partner_fonts = {} self.partner_texts = ("", "") self.partner_fit_after = None self.partner_size = (0, 0) self.partner_pending = [] self.partner_until = 0.0 self.partner_after = None self.traces = [] self.trace_seq = 0 self.trace_sel = None self.trace_follow = tk.BooleanVar(value=True) self.trace_summary_var = tk.StringVar() self.trace_list = self.trace_tree = None self.speaker = Speaker(self.params) self.tts_enabled = False self.gpu = gpu_status() self._build_ui() self._on_source_change() self._on_direction_change() self.append_text(self.t("notice"), "info", log=False) if notice: self.append_text(notice, "info", log=False) if self.results_var.get(): self._open_results_view() if settings.get("partner", False): self._open_partner_view() self._watch_speaker_ready() self.root.protocol("WM_DELETE_WINDOW", self.on_close) self.root.bind("", lambda e: self.toggle()) self.root.bind("", lambda e: self._set_view_mode("normal", fullscreen_only=True)) self._draw_meter() # ------------------------------------------------------------ 共通 @staticmethod def _valid(value, allowed, default): return value if value in allowed else default def _ui(self, func): if self.alive: self.root.after(0, func) def t(self, key, **values): """表示言語の文言を併記する。値が言語別の辞書なら、各言語の値で差し込む。""" shown = [] for lang in self.disp_langs: text = UI_TEXT[key][lang] if values: text = text.format(**{k: v[lang] if isinstance(v, dict) else v for k, v in values.items()}) shown.append(text) return join_unique(shown) def lang_name(self, code): return join_unique(LANG_NAMES[code][x] for x in self.disp_langs) @staticmethod def resolve(direction): """(認識で指定する言語。識別する場合は None, 候補言語) を返す。""" if direction.mode == "fixed": return direction.a, (direction.a,) if direction.mode == "conv": return None, (direction.a, direction.b) return None, LANGS @staticmethod def target_lang(direction, src): """翻訳先の言語。文字起こしのみの場合は None。""" if direction.mode == "fixed": return direction.b if direction.mode == "conv": return direction.b if src == direction.a else direction.a return None # ------------------------------------------------------------ 画面の部品 def _keyed(self, widget, key): """文言キーを持つウィジェットを登録し、現在の表示言語で文言を設定する。""" widget.configure(text=self.t(key)) self._texts.append((widget, key)) return widget def _row(self, parent=None, pad=(8, 6, 8, 0)): frame = ttk.Frame(parent or self.tab_run, padding=pad) frame.pack(fill="x") return frame @staticmethod def _note(parent, color="#78909c", wrap=1060, **pack): label = ttk.Label(parent, foreground=color, font=SMALL_FONT, wraplength=wrap, justify="left") label.pack(side="left", fill="x", expand=True, **pack) return label def _fill_combo(self, combo, text_keys, current): """選択肢の表示ラベルを現在の表示言語で作り直す。選択はキーで保持する。""" labels = {k: self.t(v) for k, v in text_keys.items()} combo.label_to_key = {v: k for k, v in labels.items()} combo.configure(values=list(labels.values())) combo.set(labels[current]) # ------------------------------------------------------------ 操作画面 def _build_ui(self): root = self.root root.geometry(self.settings.get("geometry", "1140x720")) root.minsize(900, 560) self.notebook = ttk.Notebook(root) self.notebook.pack(fill="both", expand=True) self.tab_run = ttk.Frame(self.notebook) self.tab_trace = ttk.Frame(self.notebook) self.tab_help = ttk.Frame(self.notebook) for tab in (self.tab_run, self.tab_trace, self.tab_help): self.notebook.add(tab, text="") self._build_run_tab() self._build_trace_tab() self._build_help_tab() self._lock_controls(False) def _build_run_tab(self): K = self._keyed # --- 翻訳方向 row = self._row(pad=(8, 8, 8, 0)) K(ttk.Label(row), "direction").pack(side="left") self.dir_combo = ttk.Combobox(row, state="readonly", values=[d.label for d in DIRECTIONS]) self.dir_combo.set(self._initial_direction().label) self.dir_combo.pack(side="left", fill="x", expand=True, padx=6) self.dir_combo.bind("<>", lambda e: self._on_direction_change()) self.swap_btn = K(ttk.Button(row, command=self.swap_direction), "swap") self.swap_btn.pack(side="left") # --- 音声の入力元 row = self._row() K(ttk.Label(row), "source").pack(side="left") self.r_mic = K(ttk.Radiobutton(row, variable=self.source_mode, value="mic", command=self._on_source_change), "src_mic") self.r_mic.pack(side="left", padx=4) self.r_file = K(ttk.Radiobutton(row, variable=self.source_mode, value="file", command=self._on_source_change), "src_file") self.r_file.pack(side="left", padx=4) row = self._row(pad=(8, 4, 8, 0)) self.mic_name_label = K(ttk.Label(row), "mic") names = [name for _i, name in self.devices] self.mic_combo = ttk.Combobox(row, state="readonly", values=names) if names: saved = self.settings.get("mic") self.mic_combo.set(saved if saved in self._mic_label_to_index else names[default_device_position(self.devices)]) self.file_btn = K(ttk.Button(row, command=self._select_file), "choose_file") self.file_lbl = ttk.Label(row, foreground="#555555") # --- モデルと実行デバイス row = self._row() K(ttk.Label(row), "model").pack(side="left") self.model_combo = ttk.Combobox(row, state="readonly", width=34) self.model_combo.pack(side="left", padx=6) self.model_combo.bind("<>", lambda e: self._on_model_change()) K(ttk.Label(row), "mtmodel").pack(side="left", padx=(12, 0)) self.mt_combo = ttk.Combobox(row, state="readonly", width=34) self.mt_combo.pack(side="left", padx=6) self.mt_combo.bind("<>", lambda e: self._on_mt_change()) row = self._row(pad=(8, 2, 8, 0)) K(ttk.Label(row), "device").pack(side="left") self.device_var = tk.StringVar(value=self._valid( self.settings.get("device"), ("cpu", "cuda") if self.gpu == "ok" else ("cpu",), "cuda" if self.gpu == "ok" else "cpu")) self.dev_cpu_radio = K(ttk.Radiobutton(row, variable=self.device_var, value="cpu", command=self._on_device_change), "dev_cpu") self.dev_cpu_radio.pack(side="left", padx=(6, 8)) self.dev_gpu_radio = K(ttk.Radiobutton(row, variable=self.device_var, value="cuda", command=self._on_device_change), "dev_gpu") self.dev_gpu_radio.pack(side="left") if self.gpu != "ok": K(ttk.Label(row, foreground="#78909c", font=SMALL_FONT, wraplength=360, justify="left"), "nogpu" if self.gpu == "nogpu" else "nocudalib").pack(side="left", padx=8) K(ttk.Label(row), "noiseenv").pack(side="left", padx=(12, 0)) self.noise_profile_var = tk.StringVar(value=self.noise_profile) self.quiet_radio = K(ttk.Radiobutton(row, variable=self.noise_profile_var, value="quiet", command=self._on_noise_profile_change), "quietmode") self.quiet_radio.pack(side="left", padx=(6, 8)) self.noisy_radio = K(ttk.Radiobutton(row, variable=self.noise_profile_var, value="noisy", command=self._on_noise_profile_change), "noisymode") self.noisy_radio.pack(side="left") self.model_note = self._note(self._row(pad=(8, 2, 8, 0)), "#455a64") # --- リアルタイム調整(スライダー) box = K(ttk.LabelFrame(self.tab_run, padding=(8, 2, 8, 4)), "params") box.pack(fill="x", padx=8, pady=(6, 0)) self.slider_specs = { "gain": ("p_gain", -40.0, -14.0, 1.0), "onset": ("p_onset", 3.0, 18.0, 0.5), "silence": ("p_silence", 0.3, 1.5, 0.1), "maxlen": ("p_maxlen", 5.0, 20.0, 0.5), "asrbeam": ("p_asrbeam", 1.0, 10.0, 1.0), "mtbeam": ("p_mtbeam", 1.0, 8.0, 1.0), "rate": ("p_rate", -10.0, 10.0, 1.0), } initial = {"gain": self.params.gain_target_db, "onset": self.params.onset_snr_db, "silence": self.params.silence_sec, "maxlen": self.params.max_utter_sec, "asrbeam": float(self.params.asr_beam), "mtbeam": float(self.params.mt_beam), "rate": float(self.params.tts_rate)} self.slider_vars = {key: tk.DoubleVar(value=value) for key, value in initial.items()} self.sliders = {} for i, (key, (text_key, low, high, step)) in enumerate(self.slider_specs.items()): r, col = divmod(i, 2) K(ttk.Label(box), text_key).grid(row=r, column=col_index(col, 0), sticky="w", padx=(0, 4)) scale = tk.Scale(box, from_=low, to=high, resolution=step, orient="horizontal", length=150, showvalue=True, variable=self.slider_vars[key], font=SMALL_FONT, sliderlength=14, width=10) scale.grid(row=r, column=col_index(col, 1), sticky="ew", padx=(0, 12)) self.sliders[key] = scale box.columnconfigure(1, weight=1) box.columnconfigure(3, weight=1) for scale in self.sliders.values(): scale.configure(command=self._on_param_change) # 変数を直接書き換えた場合(設定の復元など)にも値を反映させる。tk.Scale の command は # 利用者の操作によってのみ呼ばれるため、変数の変更を監視する。 for var in self.slider_vars.values(): var.trace_add("write", lambda *_args: self._on_param_change()) self.params_note = self._note(self._row(pad=(8, 0, 8, 0)), "#78909c") self.params_note.configure(text=self.t("paramsnote")) # --- 操作ボタンと表示の切り替え row = self._row(pad=(8, 8, 8, 0)) self.start_btn = ttk.Button(row, command=self.toggle) self.start_btn.pack(side="left") K(ttk.Button(row, command=self.clear_text), "clear").pack(side="left", padx=6) K(ttk.Button(row, command=self.open_log), "openlog").pack(side="left") K(ttk.Button(row, command=self.copy_translation), "copy").pack(side="left", padx=6) K(ttk.Label(row, foreground="#78909c", font=SMALL_FONT), "keyhint").pack(side="left", padx=8) K(ttk.Label(row), "viewmode").pack(side="left", padx=(12, 0)) K(ttk.Button(row, command=lambda: self._set_view_mode("laptop")), "view_laptop").pack( side="left", padx=4) K(ttk.Button(row, command=lambda: self._set_view_mode("full")), "view_full").pack( side="left", padx=4) K(ttk.Button(row, command=lambda: self._set_view_mode("normal")), "view_normal").pack( side="left", padx=4) # --- 表示と読み上げ row = self._row(pad=(8, 4, 8, 0)) self.tts_var = tk.BooleanVar(value=False) self.tts_check = K(ttk.Checkbutton(row, variable=self.tts_var, state="disabled", command=self._on_tts_toggle), "tts") self.tts_check.pack(side="left") self.results_var = tk.BooleanVar(value=bool(self.settings.get("results", True))) K(ttk.Checkbutton(row, variable=self.results_var, command=lambda: ( self._open_results_view if self.results_var.get() else self._close_results_view)()), "resultswin").pack(side="left", padx=(14, 0)) self.partner_var = tk.BooleanVar(value=False) K(ttk.Checkbutton(row, variable=self.partner_var, command=lambda: ( self._open_partner_view if self.partner_var.get() else self._close_partner_view)()), "partner").pack(side="left", padx=(14, 0)) K(self._note(row, wrap=620), "help_hint") row = self._row() self.voice_label = self._note(row, "#455a64") # --- 入力レベル計 row = self._row(pad=(8, 6, 8, 0)) K(ttk.Label(row), "miclevel").pack(side="left") self.meter = tk.Canvas(row, height=24, highlightthickness=1, highlightbackground="#b0bec5", bd=0) self.meter.pack(side="left", fill="x", expand=True, padx=6) self.speak_var = tk.StringVar(value="") ttk.Label(row, textvariable=self.speak_var, width=24).pack(side="left") self.meter_legend_label = self._note(self._row(pad=(8, 0, 8, 2))) # --- 結果の表示(このタブ内) frame = ttk.Frame(self.tab_run, padding=(8, 0, 8, 6)) frame.pack(fill="both", expand=True) text = self.run_text = tk.Text(frame, wrap="word", font=("Meiryo UI", 11), spacing1=2, spacing3=2, state="disabled", height=8) scroll = ttk.Scrollbar(frame, command=text.yview) text.configure(yscrollcommand=scroll.set) text.pack(side="left", fill="both", expand=True) scroll.pack(side="right", fill="y") self._configure_text_tags(text) for widget in (self.tab_run, text): widget.bind("", self._on_ctrl_wheel) self.progress = ttk.Progressbar(self.tab_run, maximum=100.0) self.status_var = tk.StringVar() self.status_label = ttk.Label(self.tab_run, textvariable=self.status_var, padding=(8, 4), wraplength=1060, justify="left") self.status_label.pack(fill="x") def _configure_text_tags(self, text): text.tag_configure("src", foreground="#555555") text.tag_configure("dst", foreground="#0d47a1") text.tag_configure("info", foreground="#8d6e63", font=("Meiryo UI", 10)) def _build_trace_tab(self): K = self._keyed top = ttk.Frame(self.tab_trace, padding=(8, 6, 8, 0)) top.pack(fill="x") K(ttk.Label(top, font=SMALL_FONT, foreground="#455a64"), "trace_japanese").pack(side="left") ttk.Label(top, textvariable=self.trace_summary_var, font=SMALL_FONT, foreground="#37474f", wraplength=620, justify="left").pack(side="left", fill="x", expand=True, padx=(8, 0)) K(ttk.Checkbutton(top, variable=self.trace_follow), "trace_follow").pack(side="left", padx=8) K(ttk.Button(top, command=self._save_trace), "trace_save").pack(side="left") body = ttk.Frame(self.tab_trace, padding=(8, 4, 8, 8)) body.pack(fill="both", expand=True) left = ttk.Frame(body) left.pack(side="left", fill="y") K(ttk.Label(left), "trace_list").pack(anchor="w") self.trace_list = tk.Listbox(left, width=32, font=("Meiryo UI", 9), exportselection=False) self.trace_list.pack(fill="both", expand=True) self.trace_list.bind("<>", self._on_trace_select) right = ttk.Frame(body) right.pack(side="left", fill="both", expand=True, padx=(8, 0)) self.trace_tree = ttk.Treeview(right, columns=("stage", "item", "value"), show="headings", height=18) for column, key, width in (("stage", "trace_stage", 90), ("item", "trace_item", 300), ("value", "trace_value", 620)): self.trace_tree.heading(column, text=self.t(key)) self.trace_tree.column(column, width=width, anchor="w", stretch=(column == "value")) for stage, color in (("入力", "#37474f"), ("区間検出", "#00695c"), ("言語識別", "#4527a0"), ("音声認識", "#1565c0"), ("棄却判定", "#ad1457"), ("翻訳", "#2e7d32"), ("表示", "#6d4c41"), ("結果", "#b71c1c")): self.trace_tree.tag_configure(stage, foreground=color) scroll = ttk.Scrollbar(right, command=self.trace_tree.yview) self.trace_tree.configure(yscrollcommand=scroll.set) self.trace_tree.pack(side="left", fill="both", expand=True) scroll.pack(side="right", fill="y") def _build_help_tab(self): frame = ttk.Frame(self.tab_help, padding=(0, 0, 0, 0)) frame.pack(fill="both", expand=True) text = tk.Text(frame, wrap="word", font=("Meiryo UI", 10), padx=16, pady=12, spacing1=2, spacing3=3) text.tag_configure("h1", font=("Meiryo UI", 16, "bold"), spacing1=6, spacing3=8) text.tag_configure("h2", font=("Meiryo UI", 13, "bold"), spacing1=14, spacing3=6) text.tag_configure("p", lmargin1=4, lmargin2=4) text.tag_configure("li", lmargin1=20, lmargin2=36) for tag, body in GUIDE: text.insert("end", ("・" + body if tag == "li" else body) + "\n", tag) text.configure(state="disabled") scroll = ttk.Scrollbar(frame, command=text.yview) text.configure(yscrollcommand=scroll.set) text.pack(side="left", fill="both", expand=True) scroll.pack(side="right", fill="y") self.help_text = text def _initial_direction(self): saved = self.settings.get("direction") if isinstance(saved, dict): for d in DIRECTIONS: if (d.mode, d.a, d.b) == (saved.get("mode"), saved.get("a"), saved.get("b")): return d return DEFAULT_DIRECTION # 保存された設定が無い場合はインドネシア語 → 日本語 # ------------------------------------------------------------ 結果の表示 def _open_results_view(self): if self.results_win is not None: self.results_win.lift() return win = self.results_win = tk.Toplevel(self.root) win.title(self.t("results")) win.geometry(self.settings.get("results_geometry", "980x640")) win.minsize(360, 200) win.protocol("WM_DELETE_WINDOW", self._close_results_view) row = ttk.Frame(win, padding=(8, 8, 8, 2)) row.pack(fill="x") for tag in ("src", "dst"): self._keyed(ttk.Label(row), tag + "font").pack(side="left") tk.Scale(row, from_=0, to=len(FONT_SCALE_STEPS) - 1, resolution=1, orient="horizontal", length=110, showvalue=False, variable=self.font_idx[tag], command=lambda _v, tag=tag: self._apply_font_scale(tag)).pack(side="left", padx=4) self.font_readout[tag] = ttk.Label(row, width=6) self.font_readout[tag].pack(side="left", padx=(0, 16)) self._keyed(self._note(row, wrap=900), "zoomhint").pack(side="left", fill="x", expand=True) frame = ttk.Frame(win, padding=(8, 0, 8, 8)) frame.pack(fill="both", expand=True) text = self.win_text = tk.Text(frame, wrap="word", font=("Meiryo UI", 11), spacing1=2, spacing3=2, state="disabled") scroll = ttk.Scrollbar(frame, command=text.yview) text.configure(yscrollcommand=scroll.set) text.pack(side="left", fill="both", expand=True) scroll.pack(side="right", fill="y") self._configure_text_tags(text) for widget in (win, text): widget.bind("", self._on_ctrl_wheel) self.results_var.set(True) for tag in ("src", "dst"): self._apply_font_scale(tag) self._render_records() def _close_results_view(self): if self.results_win is not None: self.results_win.destroy() self.results_win = self.win_text = None self.font_readout = {"src": None, "dst": None} self.results_var.set(False) def _result_texts(self): return [w for w in (self.run_text, self.win_text) if w is not None] def _apply_font_scale(self, tag): scale = FONT_SCALE_STEPS[self.font_idx[tag].get()] size = round(BASE_FONT_SIZE[tag] * scale) font = ("Meiryo UI", size, "bold") if FONT_BOLD[tag] else ("Meiryo UI", size) for text in self._result_texts(): text.tag_configure(tag, font=font) if self.font_readout[tag] is not None: self.font_readout[tag].configure(text=f"×{scale:g}") def _on_ctrl_wheel(self, event): delta = 1 if event.delta > 0 else -1 for tag in ("src", "dst"): self.font_idx[tag].set(max(0, min(self.font_idx[tag].get() + delta, len(FONT_SCALE_STEPS) - 1))) self._apply_font_scale(tag) return "break" def _render_records(self): """記録をまとめて描画し直す。""" for text in self._result_texts(): text.configure(state="normal") text.delete("1.0", "end") for message, tag in self.records: text.insert("end", message + "\n", tag) text.see("end") text.configure(state="disabled") # ------------------------------------------------------------ 相手向け表示 def _open_partner_view(self): if self.partner_win is not None: self.partner_win.lift() return win = self.partner_win = tk.Toplevel(self.root) win.title(self.t("partner")) win.geometry("900x500") win.minsize(320, 180) win.configure(bg="black") win.attributes("-topmost", True) win.protocol("WM_DELETE_WINDOW", self._close_partner_view) self.partner_fonts = {"src": tkfont.Font(root=win, family="Meiryo UI", size=18), "dst": tkfont.Font(root=win, family="Meiryo UI", size=40, weight="bold")} # 改行は wrap_text で明示するため、ラベルの自動折り返し(wraplength)は使わない self.partner_src_label = tk.Label(win, text="", fg="#9e9e9e", bg="black", font=self.partner_fonts["src"], justify="left", anchor="w") self.partner_src_label.pack(fill="x", padx=24, pady=(24, 0)) self.partner_dst_label = tk.Label(win, text="", fg="white", bg="black", font=self.partner_fonts["dst"], justify="left", anchor="nw") self.partner_dst_label.pack(fill="both", expand=True, padx=24, pady=(8, 8)) self.partner_hint_label = self._keyed( tk.Label(win, fg="#4f5b62", bg="black", font=SMALL_FONT, anchor="w"), "fullhint") self.partner_hint_label.pack(fill="x", padx=24, pady=(0, 8)) self.partner_texts = (self.t("waiting"), "") win.bind("", self._on_partner_configure) win.bind("", lambda e: self._toggle_partner_fullscreen()) win.bind("", lambda e: self._toggle_partner_fullscreen()) win.bind("", lambda e: win.attributes("-fullscreen", False)) self.partner_var.set(True) self.partner_size = (0, 0) self.partner_pending, self.partner_until = [], 0.0 self._fit_partner_font() def _close_partner_view(self): if self.partner_after is not None: self.root.after_cancel(self.partner_after) self.partner_after = None if self.partner_fit_after is not None: self.root.after_cancel(self.partner_fit_after) self.partner_fit_after = None self.partner_pending = [] if self.partner_win is not None: self.partner_win.destroy() self.partner_win = self.partner_src_label = self.partner_dst_label = None self.partner_hint_label = None self.partner_fonts = {} self.partner_var.set(False) def _post_partner(self, src_text, dst_text, lang): """結果を相手向け表示に出す(UI スレッドで呼ぶ)。 表示中の訳文が最短表示時間に達していなければ、達した時点で表示する。その間に届いた 結果は改行せずに続けて(最大 PARTNER_MERGE_MAX 件)表示し、待ち時間が積み重ならないようにする。 """ if self.partner_win is None: return self.partner_pending.append((src_text, dst_text, lang)) del self.partner_pending[:-PARTNER_MERGE_MAX] if self.partner_after is not None: return # 予約済みの表示でまとめて表示する wait = self.partner_until - time.monotonic() if wait <= 0.0: self._flush_partner() else: self.partner_after = self.root.after(int(wait * 1000) + 1, self._flush_partner) def _flush_partner(self): self.partner_after = None pending, self.partner_pending = self.partner_pending, [] if self.partner_win is None or not pending: return # まとめて表示する結果は改行せずに続けて並べる(折り返しはウィンドウの幅でのみ行う)。 # 空白で語を区切らない言語は、文末記号で終わる文の後ろには空白を入れない。 lang = pending[-1][2] src_text = " ".join(s for s, _d, _l in pending if s) dst_text = "" for _s, d, _l in pending: if not d: continue if dst_text and not (lang in NO_SPACE_LANGS and dst_text[-1] in "。.!?!?…"): dst_text += " " dst_text += d self._update_partner(src_text, dst_text) chars = len("".join(dst_text.split())) hold = chars / PARTNER_READ_CPS.get(lang, PARTNER_READ_CPS["en"]) self.partner_until = time.monotonic() + min(max(hold, PARTNER_MIN_HOLD_SEC), PARTNER_MAX_HOLD_SEC) def _update_partner(self, src_text, dst_text): if self.partner_win is None: return self.partner_texts = (src_text, dst_text) self._fit_partner_font() def _layout_partner(self, size, width, height): """訳文の文字サイズ size [pt] での配置を求める。 戻り値は (原文の行, 訳文の行, 訳文に使える行数)。原文の文字サイズは訳文の 0.42 倍(12〜40 pt)。 原文は PARTNER_SRC_MAX_LINES 行までとし、超える分は先頭を省く。 """ src_text, dst_text = self.partner_texts src_font, dst_font = self.partner_fonts["src"], self.partner_fonts["dst"] src_font.configure(size=max(12, min(int(size * 0.42), 40))) dst_font.configure(size=size) src_lines = (wrap_tail(src_text, text_measurer(src_font), width, PARTNER_SRC_MAX_LINES) if src_text else []) used = (PARTNER_PAD_Y + 2 * PARTNER_LABEL_EXTRA + self.partner_hint_label.winfo_reqheight() + max(len(src_lines), 1) * src_font.metrics("linespace")) room = max((height - used) // dst_font.metrics("linespace"), 1) return src_lines, wrap_text(dst_text, text_measurer(dst_font), width), room def _fit_partner_font(self): """訳文がウィンドウに収まる最大の文字サイズを、実際の行分割と行の高さから求めて表示する。 最小サイズ(PARTNER_MIN_FONT)でも収まらない場合は、訳文の先頭を省いて末尾を表示する。 """ self.partner_fit_after = None if self.partner_win is None: return width = max(self.partner_win.winfo_width() - PARTNER_PAD_X, 160) height = max(self.partner_win.winfo_height(), 160) low, high = PARTNER_MIN_FONT, PARTNER_MAX_FONT while low < high: # 収まる最大の文字サイズを二分探索で求める mid = (low + high + 1) // 2 _src, dst_lines, room = self._layout_partner(mid, width, height) if len(dst_lines) <= room: low = mid else: high = mid - 1 src_lines, dst_lines, room = self._layout_partner(low, width, height) if len(dst_lines) > room: dst_lines = wrap_tail(self.partner_texts[1], text_measurer(self.partner_fonts["dst"]), width, room) self.partner_src_label.configure(text="\n".join(src_lines)) self.partner_dst_label.configure(text="\n".join(dst_lines)) def _on_partner_configure(self, event): """大きさが実際に変わったときだけ、操作が止まるのを待って文字サイズを計算し直す。""" size = (event.width, event.height) if event.widget is self.partner_win and size != self.partner_size: self.partner_size = size if self.partner_fit_after is not None: self.root.after_cancel(self.partner_fit_after) self.partner_fit_after = self.root.after(PARTNER_FIT_DELAY_MS, self._fit_partner_font) def _toggle_partner_fullscreen(self): self.partner_win.attributes("-fullscreen", not bool(self.partner_win.attributes("-fullscreen"))) # ------------------------------------------------------------ 表示の一括更新 def _refresh_ui_texts(self): self.root.title(self.t("title")) self._texts = [(w, k) for w, k in self._texts if w.winfo_exists()] for widget, key in self._texts: widget.configure(text=self.t(key)) for tab, key in ((self.tab_run, "tab_run"), (self.tab_trace, "tab_trace"), (self.tab_help, "tab_help")): self.notebook.tab(tab, text=self.t(key)) self.file_lbl.configure(text=Path(self.selected_file).name if self.selected_file else self.t("nofile")) if not self.devices: self.mic_combo.set(self.t("nomic")) self._fill_combo(self.model_combo, MODEL_TEXT_KEY, self.model_key) self._fill_combo(self.mt_combo, MT_TEXT_KEY, self.mt_key) self.start_btn.configure(text=self.t("stop" if self.running else "start")) self.voice_label.configure(text=self._voice_summary()) self.meter_legend_label.configure(text=self._meter_legend_text()) self.trace_summary_var.set(self._trace_summary()) self._refresh_model_note() for win, key in ((self.results_win, "results"), (self.partner_win, "partner")): if win is not None: win.title(self.t(key)) self._show_status() def _refresh_model_note(self): """音声認識モデルと翻訳モデルの案内を更新する(実行デバイスによって内容が変わる)。""" facts = MODEL_FACTS[self.model_key] note = self.t("modelinfo", params=facts["params"], size=facts["size"]) if self.model_key == "high": note += " " + self.t("turbonote") if self.model_key in HEAVY_MODELS and self.device_var.get() == "cpu": note += " " + self.t("cpuheavy") mt_note = self.t("mtinfo", params=MT_FACTS[self.mt_key]["params"], size=MT_FACTS[self.mt_key]["size"]) if self.mt_key == "large": mt_note += " " + self.t("mtlargenote") if self.device_var.get() == "cpu": mt_note += " " + self.t("mtcpuheavy") self.model_note.configure(text=note + " " + self.t("decodenote") + " " + mt_note) def _meter_legend_text(self): p = NOISE_PROFILES[self.noise_profile] return self.t("meterlegend", block=BLOCK_SEC, margin=self.params.onset_snr_db, floor=p["abs_onset_dbfs"]) def _voice_summary(self): """言語ごとに使用する合成音声と、未取得の内蔵音声モデルを示す。""" speaker = self.speaker if not speaker.ready.is_set(): return self.t("voices") + " …" names, absent = [], [] for lang in LANGS: if speaker.has_windows_voice(lang): names.append(f"{LANG_NAMES[lang]['en']}={speaker.voice_name[lang]}") continue key = BUILTIN_MODEL_FOR_LANG[lang] names.append(f"{LANG_NAMES[lang]['en']}={BUILTIN_TTS_MODELS[key]['label']} (sherpa-onnx)") if not speaker.builtin.downloaded(key) and key not in absent: absent.append(key) notes = [self.t("ttsabsent", model=BUILTIN_TTS_MODELS[k]["label"], size=BUILTIN_TTS_MODELS[k]["size"]) for k in absent] return "\n".join([self.t("voices") + " " + ", ".join(names)] + notes) # ------------------------------------------------------------ スライダー def _sync_sliders(self): """スライダーの表示を Params の現在の値に合わせる。""" p = self.params for key, value in (("gain", p.gain_target_db), ("onset", p.onset_snr_db), ("silence", p.silence_sec), ("maxlen", p.max_utter_sec), ("asrbeam", float(p.asr_beam)), ("mtbeam", float(p.mt_beam)), ("rate", float(p.tts_rate))): self.slider_vars[key].set(value) self.meter_legend_label.configure(text=self._meter_legend_text()) def _on_param_change(self, _value=None): """スライダーの変更を Params に反映する(次のブロック・発話・復号から効く)。""" p = self.params p.gain_target_db = float(self.slider_vars["gain"].get()) p.onset_snr_db = float(self.slider_vars["onset"].get()) p.silence_sec = float(self.slider_vars["silence"].get()) p.max_utter_sec = float(self.slider_vars["maxlen"].get()) p.asr_beam = int(round(float(self.slider_vars["asrbeam"].get()))) p.mt_beam = int(round(float(self.slider_vars["mtbeam"].get()))) p.tts_rate = int(round(float(self.slider_vars["rate"].get()))) if getattr(self, "meter_legend_label", None) is not None: # 構築中は未生成 self.meter_legend_label.configure(text=self._meter_legend_text()) # ------------------------------------------------------------ 表示の大きさ def _set_view_mode(self, kind, fullscreen_only=False): """窓の大きさを切り替える。laptop は高さ 768 画素の画面に収まる大きさにする。""" if kind == "full": self.root.attributes("-fullscreen", True) return self.root.attributes("-fullscreen", False) if fullscreen_only: return self.root.geometry("1140x720" if kind == "laptop" else self.settings.get("geometry", "1140x720")) # ------------------------------------------------------------ 選択の変更 def _on_direction_change(self): direction = self.direction = DIRECTION_BY_LABEL[self.dir_combo.get()] self.disp_langs = (list(DISPLAY_ORDER) if direction.mode == "asr" else display_langs(direction.a, direction.b)) self.last_key = "" self.swap_btn.configure(state="normal" if direction.mode == "fixed" else "disabled") self._refresh_ui_texts() self._prepare_tts_async() def swap_direction(self): d = self.direction self.dir_combo.set(next(o.label for o in DIRECTIONS[:N_FIXED] if (o.a, o.b) == (d.b, d.a))) self._on_direction_change() def _on_model_change(self): self.model_key = self.model_combo.label_to_key[self.model_combo.get()] self._refresh_model_note() def _on_mt_change(self): self.mt_key = self.mt_combo.label_to_key[self.mt_combo.get()] self._refresh_model_note() def _on_device_change(self): self._refresh_model_note() def _on_tts_toggle(self): self.tts_enabled = self.tts_var.get() if self.tts_enabled: self._prepare_tts_async() else: self.speaker.stop_speaking() def _on_noise_profile_change(self): """使用環境を切り替える。しきい値と無音時間を推奨値に戻し、区間検出器を作り直す。 使用環境の選択は動作中には変更できない(_lock_controls で無効にする)ため、動作中の 区間検出器と設定が食い違うことはない。 """ self.noise_profile = self.noise_profile_var.get() self.params.apply_profile(self.noise_profile) self.segmenter = Segmenter(self.noise_profile, self.params) self._sync_sliders() def _on_source_change(self): for widget in (self.mic_name_label, self.mic_combo, self.file_btn, self.file_lbl): widget.pack_forget() if self.source_mode.get() == "mic": self.mic_name_label.pack(side="left") self.mic_combo.pack(side="left", fill="x", expand=True, padx=6) else: self.file_btn.pack(side="left", padx=(0, 6)) self.file_lbl.pack(side="left", fill="x", expand=True, padx=6) self._refresh_start_button() def _select_file(self): path = filedialog.askopenfilename( filetypes=[(self.t("audiofile"), "*.wav *.mp3 *.m4a *.flac *.ogg"), (self.t("allfiles"), "*.*")]) if path: self.selected_file = path self.file_lbl.configure(text=Path(path).name) self._refresh_start_button() def _refresh_start_button(self): """入力元が使える状態のときだけ「開始」を押せるようにする(停止はいつでも可能)。""" ready = (bool(self.devices) if self.source_mode.get() == "mic" else bool(self.selected_file) and Path(self.selected_file).is_file()) self.start_btn.configure( state="normal" if self.running or (ready and not self.busy) else "disabled") def _lock_controls(self, locked): """動作中に変更すると設定と動作が食い違う選択肢を無効にする(スライダーは常に有効)。""" state = "disabled" if locked else "normal" self.mic_combo.configure(state="disabled" if locked or not self.devices else "readonly") for combo in (self.model_combo, self.mt_combo): combo.configure(state="disabled" if locked else "readonly") for widget in (self.file_btn, self.r_mic, self.r_file, self.dev_cpu_radio, self.quiet_radio, self.noisy_radio): widget.configure(state=state) self.dev_gpu_radio.configure(state="normal" if self.gpu == "ok" and not locked else "disabled") # ------------------------------------------------------------ 開始と停止 def toggle(self): if self.start_btn.instate(["disabled"]): return if self.running: self.stop() else: self.start() def start(self): self._ensure_log_file() self._log_write(f"[{datetime.now():%H:%M:%S}] {self.direction.label}") self._save_settings() self.busy = True self.input_mode = self.source_mode.get() self.start_btn.configure(state="disabled") self._lock_controls(True) self.speaker.ensure_running() if self.direction.mode != "fixed": self.append_text(self.t("langidnote"), "info", log=False) mic = self._mic_label_to_index[self.mic_combo.get()] if self.input_mode == "mic" else None threading.Thread(target=self._start_worker, args=(mic, self.device_var.get(), self.model_key, self.mt_key), daemon=True).start() def stop(self, status="stopped"): self.running = self.speaking = self.busy = False self.session += 1 # 進行中の処理を打ち切る self._close_stream() self.speaker.stop_speaking() self.level_db = METER_MIN_DB self._lock_controls(False) self.start_btn.configure(text=self.t("start")) self._refresh_start_button() self._set_progress(None) self.set_status(status) def _start_worker(self, mic, device, model_key, mt_key): """モデルを用意してから処理を始める。mic はマイクの番号(音声ファイルの場合は None)。""" self.engine.load(device, model_key, mt_key, self._report_load) self._log_conditions() if self.tts_enabled: # 内蔵音声が必要な言語は、発話を待ち受ける前に準備しておく(取得は初回のみ) self._prepare_tts(self._builtin_keys()) self._ui(lambda: self._set_progress(None)) self.session += 1 session = self.session self.running = True self.busy = False self._ui(lambda: self.start_btn.configure(text=self.t("stop"), state="normal")) self._ui(self._prepare_tts_async) if mic is not None: self._run_microphone(session, mic) else: self.set_status("fileproc", Path(self.selected_file).name) self.append_text(self.t("batchnote"), "info", log=False) self._process_file(self.selected_file, session) def _report_load(self, key, got, total): self.set_status(key, f"{got / 1e6:.0f} / {total / 1e6:.0f} MB" if total else "") self._ui(lambda: self._set_progress(got / total * 100.0 if total else None)) def _set_progress(self, percent): """進捗バーを表示する。percent が None のときは隠す。""" shown = self.progress.winfo_ismapped() if percent is None: if shown: self.progress.pack_forget() return if not shown: self.progress.pack(fill="x", padx=8, pady=(0, 2), before=self.status_label) self.progress["value"] = max(0.0, min(100.0, percent)) def _close_stream(self): if self.stream is not None: self.stream.close() # 動作中のストリームは中止してから閉じられる self.stream = None def _on_stream_lost(self): if self.running: self.stop("miclost") # ------------------------------------------------------------ マイク def _run_microphone(self, session, mic): self.audio_queue = queue.Queue() self.utterance_queue = queue.Queue() self.segmenter = Segmenter(self.noise_profile, self.params) self.shown_db = METER_MIN_DB self.last_key = "" def audio_cb(indata, _frames, _time_info, _status): # 合成音声の再生中も入力は破棄しない。自己音声は認識後に文字列を照合して除く。 if self.running: self.audio_queue.put(indata[:, 0].copy()) self.stream = sd.InputStream(device=mic, samplerate=SAMPLE_RATE, channels=1, dtype="float32", blocksize=BLOCK_SIZE, callback=audio_cb) self.stream.start() self.set_status("calibrating", sec=CALIB_SEC) threading.Thread(target=self._segment_loop, args=(session,), daemon=True).start() self._worker_loop(session) def _segment_loop(self, session): segmenter = self.segmenter calibrating = True last_voice = time.monotonic() while self.running and self.session == session: if self.stream is not None and not self.stream.active: self._ui(self._on_stream_lost) return try: block = self.audio_queue.get(timeout=0.2) except queue.Empty: continue utterance = segmenter.push(block, self.speaker.is_speaking()) if float(np.max(np.abs(block))) >= CLIP_PEAK: self.clip_time = time.monotonic() self.level_db = to_db(segmenter.level) self.noise_db = to_db(segmenter.noise) self.thresh_db = segmenter.onset_threshold_db() self.speaking = segmenter.voiced if calibrating and not segmenter.calibrating: calibrating = False self._back_to_listening(session) if utterance is not None: self.utterance_queue.put(utterance) if segmenter.voiced or utterance is not None: last_voice = time.monotonic() elif not calibrating and self.status_key == "listening": idle = int(time.monotonic() - last_voice) if idle >= IDLE_NOTICE_SEC and self.status_values.get("idle") != idle: # 処理が止まっていないことが分かるよう、経過秒数を 1 秒ごとに更新する self.set_status("listening", self.t("idle", sec=idle), idle=idle) utterance = segmenter.finish() if utterance is not None: self.utterance_queue.put(utterance) self.speaking = False def _worker_loop(self, session): while self.running and self.session == session: try: utterance = self.utterance_queue.get(timeout=0.2) except queue.Empty: continue self._process(utterance, session) # ------------------------------------------------------------ 自己音声の判定 def _register_spoken(self, text): key = compare_key(text) if key: self.spoken.append((key, time.monotonic())) def _is_self_echo(self, text, tts_ratio): """マイクが拾った本アプリの合成音声かどうかを、直前に合成した文との類似度で判定する。""" key = compare_key(text) if len(key) < SELF_ECHO_MIN_CHARS: return False # 短い相槌を誤って除かない now = time.monotonic() best = 0.0 for spoken_key, when in list(self.spoken): if now - when > SELF_ECHO_WINDOW_SEC: continue if len(key) >= SELF_ECHO_CONTAIN_CHARS and (key in spoken_key or spoken_key in key): return True best = max(best, difflib.SequenceMatcher(None, key, spoken_key).ratio()) # 区間の大半が再生中だった場合は、認識結果が崩れている可能性を考慮して低いしきい値を使う return best >= SELF_ECHO_RATIO or (tts_ratio >= SELF_ECHO_OVERLAP and best >= SELF_ECHO_LOOSE_RATIO) # ------------------------------------------------------------ 認識と翻訳 def _process(self, utter, session): self.trace_seq += 1 trace = Trace(self.trace_seq, datetime.now().strftime("%H:%M:%S")) self._process_one(utter, session, trace) self._publish_trace(trace) def _process_one(self, utter, session, tr): direction = self.direction fixed_lang, candidates = self.resolve(direction) audio, gain_db, peak = normalize(utter.audio, self.params.gain_target) mono_now, wall_now = time.monotonic(), datetime.now() stamp = lambda t: f"{(wall_now - timedelta(seconds=mono_now - t)):%H:%M:%S.%f}"[:-3] tr.add("入力", "区間の長さ", f"{utter.audio.size / SAMPLE_RATE:.2f} 秒({utter.blocks} ブロック、うち無音でないもの " f"{utter.active})") tr.add("入力", "区間を確定した理由", SPLIT_REASON.get(utter.reason, utter.reason)) tr.add("入力", "区間の先頭と末尾(PC がブロックを処理した時刻)", f"{stamp(utter.start)} – {stamp(utter.end)}") tr.add("入力", "正規化前の標本ピーク", f"{to_db(peak):.1f} dBFS") tr.add("入力", "正規化の利得", f"{gain_db:.1f} dB") tr.add("入力", "正規化後の実効値", f"{to_db(float(np.sqrt(np.mean(audio ** 2)))):.1f} dBFS") tr.add("入力", "合成音声を再生していたブロックの割合", f"{utter.tts_ratio * 100:.0f} %") segmenter = self.segmenter tr.add("区間検出", "暗騒音の推定値", f"{to_db(segmenter.noise):.1f} dBFS") tr.add("区間検出", "発話開始のしきい値", f"{segmenter.onset_threshold_db():.1f} dBFS(開始 SN 比 " f"{self.params.onset_snr_db:.1f} dB、絶対下限 {segmenter.abs_onset_dbfs:.0f} dBFS)") tr.add("区間検出", "無音でなかったブロックの割合", f"{utter.active} / {utter.blocks} = {utter.active / max(utter.blocks, 1) * 100:.0f} %" f"(開始判定に要する数 {segmenter.onset_blocks})") started = time.perf_counter() self.set_status("recognizing") rec = self.engine.recognize(audio, fixed_lang, candidates) if self.session != session: return spec = ASR_SPECS[self.engine.model_key] tr.add("音声認識", "モデルと計算型", f"{spec[0]}({spec[1]})/ {self.engine.compute_type} / ビーム幅 {self.params.asr_beam}") tr.add("音声認識", "温度の列", ", ".join(f"{t:.1f}" for t in ASR_TEMPERATURES) + f"(圧縮率のしきい値 {ASR_COMPRESSION_MAX}、非発話確率のしきい値 {ASR_NO_SPEECH_MAX})") tr.add("音声認識", "認識された区間", f"{len(rec.parts)} 件") for part in rec.parts: tr.add("音声認識", f"{part.start:.2f}–{part.end:.2f} 秒(非発話 {part.no_speech:.3f}、" f"圧縮率 {part.compression:.2f})", short(part.text, 200)) if rec.lang is None: self.nospeech += 1 tr.add("結果", "判定", "発話が検出されず、認識していない") self._back_to_listening(session, self.t("nospeech")) return tr.add("言語識別", "実行", "行っていない(翻訳方向で言語を固定)" if fixed_lang is not None else "行った(発話部分の先頭 30 秒)") if rec.probs: tr.add("言語識別", "候補の事後確率", "、".join(f"{LANG_NAMES[c]['ja']} {rec.probs.get(c, 0.0) * 100:.1f} %" for c in candidates)) tr.add("言語識別", "採用した言語", f"{LANG_NAMES[rec.lang]['ja']}({rec.posterior * 100:.1f} %)") tr.add("言語識別", "文字体系による補正", "補正した言語で復号し直した" if rec.rerun else "行っていない") else: tr.add("言語識別", "採用した言語", f"{LANG_NAMES[rec.lang]['ja']}(固定)") text = ("" if rec.lang in NO_SPACE_LANGS else " ").join(p.text for p in rec.parts).strip() tr.head = text if not text: self.nospeech += 1 tr.add("結果", "判定", "認識結果が空のため、表示しない") self._back_to_listening(session, self.t("nospeech")) return key = compare_key(text) now = time.monotonic() echo = self._is_self_echo(text, utter.tts_ratio) duplicate = (len(key) >= DUP_MIN_CHARS and key == self.last_key and now - self.last_key_time < DUP_WINDOW_SEC) self.last_key, self.last_key_time = key, now checks = ( ("本アプリの合成音声との類似", "該当(破棄)" if echo else "該当せず"), ("定型句・繰り返し", "該当(破棄)" if is_hallucination(text) else "該当せず"), ("文字体系の矛盾", "該当(破棄)" if script_conflicts(text, rec.lang) else "該当せず"), ("発話区間の合計長", f"{sum(p.end - p.start for p in rec.parts):.2f} 秒" f"(発話とみなす下限 {MIN_SPEECH_SEC} 秒)" + ("" if plausible_speech(rec.parts, rec.duration) else "(不足)")), ("短文雑音", "該当(破棄)" if short_noise(rec.parts, text) else "該当せず"), ("短時間内の重複", "該当(破棄)" if duplicate else "該当せず"), ) for name, result in checks: tr.add("棄却判定", name, result) if echo: self.echoes += 1 tr.add("結果", "判定", "本アプリの合成音声として破棄") self._back_to_listening(session, self.t("echodrop", n=self.echoes)) return if not plausible_speech(rec.parts, rec.duration) or is_hallucination(text) \ or script_conflicts(text, rec.lang) or short_noise(rec.parts, text) or duplicate: self.ignored += 1 tr.add("結果", "判定", "雑音・誤認識・重複として破棄") self._back_to_listening(session, self.t("ignored", n=self.ignored)) return dst = self.target_lang(direction, rec.lang) head = f"[{datetime.now():%H:%M:%S}] ({self.lang_name(rec.lang)}" if fixed_lang is None: head += f", {self.t('langid')} {rec.posterior * 100:.0f}%" self._show_source(head + ")", text) if dst is None: self.last_translation = text tr.add("翻訳", "実行", "行っていない(文字起こしのみ)") self._ui(lambda: self._post_partner("", text, rec.lang)) self.append_text("", "info", log=False) else: self.set_status("translating") result = self.engine.translate(text, rec.lang, dst) if self.session != session: return mt = MT_SPECS[self.engine.mt_key] tr.add("翻訳", "モデルとビーム幅", f"{self.params.mt_beam} / n-gram 禁止長 " f"{MT_NO_REPEAT_NGRAM['cjk' if dst in NO_SPACE_LANGS else 'spaced']}" f"({mt[0]}、{mt[1]})") tr.add("翻訳", "文の分割", f"{len(split_sentences(text))} 文") for sentence, n_tokens, out in result.rows: tr.add("翻訳", f"{n_tokens} トークン", f"{short(sentence, 90)} → {short(out, 160)}") self._show_translation(text, result.text, dst) self._notify_level(gain_db, peak) extra = self.t("elapsed", sec=time.perf_counter() - started) pending = self.utterance_queue.qsize() if pending: extra += " " + self.t("pending", n=pending) if pending >= 3 and not self.behind_notified: self.behind_notified = True self.append_text(self.t("behind"), "info", log=False) tr.add("表示", "認識開始から表示までの時間", f"{time.perf_counter() - started:.2f} 秒") self._back_to_listening(session, extra) # ------------------------------------------------------------ 音声ファイル def _process_file(self, path, session): direction = self.direction fixed_lang, candidates = self.resolve(direction) rec = self.engine.recognize(path, fixed_lang, candidates, batched=True) if rec.lang is None: self.nospeech += 1 self._ui(lambda: self.stop("nospeech")) return dst = self.target_lang(direction, rec.lang) spec = ASR_SPECS[self.engine.model_key] total = max(rec.duration, 0.001) for part in rec.parts: if not self.running or self.session != session: break self.trace_seq += 1 tr = Trace(self.trace_seq, datetime.now().strftime("%H:%M:%S")) tr.head = part.text tr.add("音声認識", "区間", f"{part.start:.2f}–{part.end:.2f} 秒(非発話 {part.no_speech:.3f}、" f"圧縮率 {part.compression:.2f})") tr.add("音声認識", "モデルと計算型", f"{spec[0]}({spec[1]})/ {self.engine.compute_type} / " f"ビーム幅 {self.params.asr_beam}") if is_hallucination(part.text) or script_conflicts(part.text, rec.lang): tr.add("棄却判定", "定型句・文字体系", "該当(破棄)") self._publish_trace(tr) self.ignored += 1 continue self._show_source( f"[{format_sec(part.start)} - {format_sec(part.end)}] ({self.lang_name(rec.lang)})", part.text) percent = min(part.end / total, 1.0) * 100.0 self._ui(lambda p=percent: self._set_progress(p)) if dst is None: self.last_translation = part.text tr.add("翻訳", "実行", "行っていない(文字起こしのみ)") self._ui(lambda t=part.text: self._post_partner("", t, rec.lang)) self.append_text("", "info", log=False) else: result = self.engine.translate(part.text, rec.lang, dst) if not self.running or self.session != session: self._publish_trace(tr) break tr.add("翻訳", "モデルとビーム幅", f"ビーム幅 {self.params.mt_beam} / {len(result.rows)} 文") for sentence, n_tokens, out in result.rows: tr.add("翻訳", f"{n_tokens} トークン", f"{short(sentence, 90)} → {short(out, 160)}") self._show_translation(part.text, result.text, dst) self._publish_trace(tr) if self.running and self.session == session: self._ui(lambda: self.stop("filedone")) # ------------------------------------------------------------ 表示 def _show_source(self, head, text): # 相手向け表示は訳文が得られた時点で原文と組にして更新する(認識の完了時に表示中の # 訳文を消さないため) self.append_text(f"{head} {text}", "src") def _show_translation(self, source_text, translated, dst): self.append_text(f"→ {translated}", "dst") self.last_translation = translated self._ui(lambda: self._post_partner(source_text, translated, dst)) self._speak(translated, dst) self.append_text("", "info", log=False) def _speak(self, text, lang): """読み上げる。内蔵音声の準備中(初回の取得中など)に得られた訳文は読み上げない。""" if self.tts_enabled and text and self.speaker.can_speak(lang): # 合成の前に登録し、マイクが拾った場合はこれと照合して破棄する self._register_spoken(text) self.speaker.speak(text, lang) def _notify_level(self, gain_db, peak): """入力レベルの問題を、それぞれ 1 回だけ案内する。""" if peak >= CLIP_PEAK and not self.clip_notified: self.clip_notified = True self.append_text(self.t("clipping", peak=to_db(peak)), "info", log=False) elif gain_db >= LOW_MIC_GAIN_DB and not self.low_mic_notified: self.low_mic_notified = True self.append_text(self.t("lowmic", gain=gain_db), "info", log=False) def append_text(self, message, tag="dst", log=True): """結果ウィンドウに 1 行追加する(どのスレッドからも呼べる)。log が真ならログにも書く。""" if log and message: self._log_write(message) self._ui(lambda: self._append_record(message, tag)) def _append_record(self, message, tag): self.records.append((message, tag)) del self.records[:-MAX_RECORDS] for text in self._result_texts(): text.configure(state="normal") text.insert("end", message + "\n", tag) if int(text.index("end-1c").split(".")[0]) > MAX_RECORDS: text.delete("1.0", "500.0") text.see("end") text.configure(state="disabled") def set_status(self, key, extra="", **values): self.status_key, self.status_extra, self.status_values = key, extra, values self._ui(self._show_status) def _show_status(self): message = self.t(self.status_key, **self.status_values) self.status_var.set(f"{message} {self.status_extra}" if self.status_extra else message) def _back_to_listening(self, session, extra=""): if self.running and self.session == session: self.set_status("listening", extra) # ------------------------------------------------------------ 入力レベル計 def _draw_meter(self): if not self.alive: return canvas = self.meter width, height = canvas.winfo_width(), canvas.winfo_height() canvas.delete("all") if width > 20 and height > 10: span = METER_MAX_DB - METER_MIN_DB def x_of(db): ratio = (min(max(db, METER_MIN_DB), METER_MAX_DB) - METER_MIN_DB) / span return 1 + int(ratio * (width - 2)) canvas.create_rectangle(0, 0, width, height, fill="#eceff1", outline="") for db in range(int(METER_MIN_DB) + 10, 1, 10): # 10 dB 間隔の目盛 canvas.create_line(x_of(db), height - 5, x_of(db), height - 1, fill="#b0bec5") if self.running and self.source_mode.get() == "mic": # 上昇には即時に追従し、下降は METER_RELEASE_DB_PER_SEC で減衰させる decay = METER_RELEASE_DB_PER_SEC * METER_MS / 1000.0 self.shown_db = shown = max(self.level_db, self.shown_db - decay) color = ("#e53935" if time.monotonic() - self.clip_time < CLIP_HOLD_SEC else "#43a047" if shown >= self.thresh_db else "#90a4ae") canvas.create_rectangle(1, 2, x_of(shown), height - 6, fill=color, outline="") canvas.create_line(x_of(self.noise_db), 1, x_of(self.noise_db), height - 1, fill="#78909c", dash=(2, 3)) canvas.create_line(x_of(self.thresh_db), 0, x_of(self.thresh_db), height, fill="#fb8c00", width=2) canvas.create_text(width - 5, height // 2, anchor="e", text=f"{shown:.0f} dBFS", font=SMALL_FONT) self.speak_var.set(self.t("speaking") if (self.running and self.speaking) else "") self.root.after(METER_MS, self._draw_meter) # ------------------------------------------------------------ 処理過程タブ def _trace_summary(self): dropped = self.segmenter.dropped return self.t("trace_summary", ok=self.trace_seq, short=dropped["short"], quiet=dropped["quiet"], inactive=dropped["inactive"], ignored=self.ignored, echo=self.echoes, nospeech=self.nospeech) def _publish_trace(self, trace): """算出過程を一覧に加える(worker スレッドから呼び、UI スレッドで反映する)。""" def apply(): self.traces.append(trace) del self.traces[:-MAX_TRACES] self.trace_list.insert("end", trace.label()) if self.trace_list.size() > MAX_TRACES: self.trace_list.delete(0) self.trace_summary_var.set(self._trace_summary()) if self.trace_follow.get(): self.trace_list.selection_clear(0, "end") self.trace_list.selection_set("end") self.trace_list.see("end") self._show_trace(len(self.traces) - 1) self._ui(apply) def _show_trace(self, index): if not 0 <= index < len(self.traces): return self.trace_sel = index tree = self.trace_tree tree.delete(*tree.get_children()) for stage, item, value in self.traces[index].rows: tree.insert("", "end", values=(stage, item, short(value, 240)), tags=(stage,)) def _on_trace_select(self, _event=None): selection = self.trace_list.curselection() if selection: self._show_trace(int(selection[0])) def _save_trace(self): """すべての発話の算出過程を TSV で保存する(表計算ソフトで開ける形式)。""" if not self.traces: self.set_status("trace_none") return LOG_DIR.mkdir(parents=True, exist_ok=True) path = LOG_DIR / f"trace_{datetime.now():%Y%m%d_%H%M%S}.tsv" with path.open("w", encoding="utf-8-sig") as out: out.write("発話\t時刻\t段階\t項目\t値\n") for trace in self.traces: for stage, item, value in trace.rows: cells = (str(trace.index), trace.when, stage, item, value) out.write("\t".join(" ".join(c.split()) for c in cells) + "\n") self.set_status("trace_saved", str(path)) # ------------------------------------------------------------ ログ def _ensure_log_file(self): """会話ログの書き出し先を用意する。以後の行は逐次保存される。""" if self.log_file is not None: return LOG_DIR.mkdir(parents=True, exist_ok=True) self.log_path = LOG_DIR / f"conversation_{datetime.now():%Y%m%d_%H%M%S}.txt" self.log_file = self.log_path.open("w", encoding="utf-8-sig", buffering=1) self.log_file.write(f"{UI_TEXT['title']['ja']} / {UI_TEXT['title']['en']}" f" {datetime.now():%Y-%m-%d %H:%M:%S}\n" + "-" * 60 + "\n") self.append_text(f"{self.t('autolog')} {self.log_path}", "info", log=False) def _log_conditions(self): """この実行の条件をログに残す(第三者が結果を追跡・再現するための記録)。""" d = self.engine.describe() p = self.params for line in ( "[実行条件]", f" 翻訳方向: {self.direction.label}", f" 音声認識モデル: {d['asr_label']} ({d['asr_repo']})", f" 翻訳モデル: {d['mt_label']} ({d['mt_repo']})", f" 実行デバイス: {d['device']} / 計算型: {d['compute_type']}", f" ビーム幅: 認識 {p.asr_beam} / 翻訳 {p.mt_beam}", f" 温度の列: {', '.join(f'{t:.1f}' for t in ASR_TEMPERATURES)}" f" / 圧縮率のしきい値 {ASR_COMPRESSION_MAX} / 非発話確率のしきい値 {ASR_NO_SPEECH_MAX}", " Silero VAD: " + ", ".join(f"{k}={v}" for k, v in VAD_PARAMS.items()), f" 入力: {SAMPLE_RATE} Hz モノラル / ブロック {BLOCK_SEC:.1f} 秒" f" / 帯域 {BAND_LOW_HZ:.0f}–{BAND_HIGH_HZ:.0f} Hz / 高域通過 {HPF_CUTOFF_HZ:.0f} Hz", f" 目標実効値 {p.gain_target_db:.0f} dBFS / ピーク上限 {PEAK_CEIL}" f" / 最大利得 {MAX_GAIN_DB:.0f} dB", f" 発話区間検出: 開始 SN 比 {p.onset_snr_db:.1f} dB / 無音 {p.silence_sec:.1f} 秒" f" / 最大発話長 {p.max_utter_sec:.1f} 秒 / 使用環境 {self.noise_profile}", " ライブラリ: " + ", ".join(library_versions()), ): self._log_write(line) def _log_write(self, line): if self.log_file is not None: self.log_file.write(line + "\n") def open_log(self): """保存済みの会話ログを既定のアプリで開く。まだ無ければログのフォルダを開く。""" if self.log_path is not None and self.log_path.is_file(): os.startfile(str(self.log_path)) else: LOG_DIR.mkdir(parents=True, exist_ok=True) os.startfile(str(LOG_DIR)) # ------------------------------------------------------------ 設定・消去 def _save_settings(self): direction = self.direction data = { "direction": {"mode": direction.mode, "a": direction.a, "b": direction.b}, "device": self.device_var.get(), "model": self.model_key, "mt": self.mt_key, "params": self.params.as_dict(), "noise": self.noise_profile, "source": self.source_mode.get(), "file": self.selected_file, "mic": self.mic_combo.get(), "tts": bool(self.tts_var.get()), "results": bool(self.results_var.get()), "partner": bool(self.partner_var.get()), "fonts": {tag: var.get() for tag, var in self.font_idx.items()}, "geometry": self.root.winfo_geometry(), } if self.results_win is not None: data["results_geometry"] = self.results_win.winfo_geometry() save_settings(data) def clear_text(self): self.records.clear() self.low_mic_notified = self.clip_notified = self.behind_notified = False self.ignored = self.echoes = self.nospeech = 0 self.segmenter.dropped.clear() self.traces.clear() self.trace_seq = 0 self.trace_list.delete(0, "end") self.trace_tree.delete(*self.trace_tree.get_children()) self.last_key = "" self._render_records() self.trace_summary_var.set(self._trace_summary()) def copy_translation(self): if not self.last_translation: self.set_status("notext") return self.root.clipboard_clear() self.root.clipboard_append(self.last_translation) self.set_status("copied") # ------------------------------------------------------------ 音声合成の準備 def _watch_speaker_ready(self): """Windows の音声の検索が済んだら読み上げを使えるようにする。 Windows に音声が無い言語も内蔵音声で読み上げられるため、常に有効にする。""" def apply(): self._refresh_voice_label() self.tts_check.configure(state="normal") if self.settings.get("tts"): self.tts_var.set(True) self._on_tts_toggle() threading.Thread(target=lambda: (self.speaker.ready.wait(), self._ui(apply)), daemon=True).start() def _refresh_voice_label(self): if self.alive: self.voice_label.configure(text=self._voice_summary()) def _builtin_keys(self): """現在の翻訳方向で訳文を読み上げる言語のうち、Windows に音声が無い言語に使う内蔵モデル。 Windows の音声の検索が済むまで待ってから判定する。 """ self.speaker.ready.wait() d = self.direction langs = (d.b,) if d.mode == "fixed" else (d.a, d.b) if d.mode == "conv" else () return list(dict.fromkeys(BUILTIN_MODEL_FOR_LANG[lang] for lang in langs if not self.speaker.has_windows_voice(lang))) def _prepare_tts(self, keys): """内蔵音声を準備する(呼び出し元のスレッドで完了まで待つ)。進捗は状態表示と進捗バーに示す。""" for key in keys: self.speaker.builtin.prepare(key, self._report_load) self._ui(self._refresh_voice_label) def _prepare_tts_async(self): """動作中に読み上げを有効にした、または翻訳方向を変えた場合に、必要な内蔵音声を準備する。 停止中は準備せず、次の開始時に準備する。""" if not (self.tts_enabled and self.running): return session, mode = self.session, self.input_mode def work(): builtin = self.speaker.builtin keys = [key for key in self._builtin_keys() if key not in builtin.loaded or not builtin.alive()] if not keys: return self._prepare_tts(keys) self._ui(lambda: self._set_progress(None)) if mode == "mic": self._back_to_listening(session) elif self.running and self.session == session: self.set_status("fileproc", Path(self.selected_file).name) threading.Thread(target=work, daemon=True).start() # ------------------------------------------------------------ 予期しない失敗の受け口 def _thread_exception(self, args): if args.exc_type is not SystemExit: self._abort(args.exc_value) def _tk_exception(self, _exc_type, exc_value, _exc_tb): self._abort(exc_value) def _abort(self, exc): """通信の失敗や GPU のメモリ不足など、コードでは防げない失敗を受け、停止して原因を表示する。 ここで処理を続行したり、別の処理で置き換えたりはしない。停止して原因を示すことが、 誤った結果を表示しないための唯一の扱いである。 """ detail = f"{type(exc).__name__}: {exc}".strip() if len(detail) > 300: detail = detail[:300] + "…" if any(word in detail.lower() for word in ("out of memory", "cuda", "cudnn")): detail += " " + self.t("oomhint") def _do(): if self.running or self.busy: self.stop("aborted") else: self._lock_controls(False) self._refresh_start_button() self.append_text(f"{self.t('aborted')} {detail}", "info", log=False) self.set_status("aborted", detail) self._ui(_do) def on_close(self): self._save_settings() self.alive = False self.running = False self._close_stream() self.speaker.shutdown() if self.log_file is not None: self.log_file.close() self.log_file = None self.root.destroy() def col_index(pair, offset): """スライダーを 1 行に 2 個並べるための grid の列番号(pair は 0 か 1)。""" return pair * 2 + offset def set_dpi_awareness(): """高 DPI 環境で画面がぼやけるのを防ぐ(Per-Monitor DPI Aware)。 Windows 8.1 以降で利用できる shcore の機能であるかを hasattr で確かめてから呼ぶ。 """ if hasattr(ctypes.windll, "shcore"): ctypes.windll.shcore.SetProcessDpiAwareness(2) def main(): # 実行ファイル化した場合、内蔵音声合成の子プロセスも同じ実行ファイルとして起動され、ここで子 # プロセスの処理に切り替わる。子プロセスが呼び出す関数を定義し終えた後に呼ぶ必要がある # (spawn は関数を名前で参照するため)。 multiprocessing.freeze_support() set_dpi_awareness() root = tk.Tk() TranslatorApp(root) root.mainloop() if __name__ == "__main__": main()