From 53ccbcf67775d18d44d50ae8fb6fc8a5dfe088cf Mon Sep 17 00:00:00 2001 From: EJClaw Date: Fri, 9 Oct 2026 02:27:41 +0900 Subject: [PATCH] =?UTF-8?q?fix:=20=ED=95=9C=EA=B5=AD=EC=9D=B8=20=EC=96=B5?= =?UTF-8?q?=EC=96=91=20=EC=98=81=EC=96=B4=EB=A5=BC=20=ED=95=9C=EA=B5=AD?= =?UTF-8?q?=EC=96=B4=EB=A1=9C=20=EA=B0=90=EC=A7=80=ED=95=B4=20=ED=95=9C?= =?UTF-8?q?=EA=B8=80=20=EC=9D=8C=EC=B0=A8=EB=A1=9C=20=EC=A0=81=EB=8D=98=20?= =?UTF-8?q?=EA=B2=83?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 원본 언어가 '자동 감지'일 때 Whisper 는 말의 언어보다 억양을 보고 언어를 고른다. 한국어 화자가 말한 영어는 한국어로 감지되고 "스나이퍼 온 더 루프탑" 처럼 소리 나는 대로 적혀, 원문=번역 언어가 되어 번역도 건너뛰었다. 실측(한국어 TTS 가 영어를 읽은 10문장): small·turbo 모두 10/10 한국어 감지. 번역 대상 언어(또는 지원 밖 언어)로 감지된 확정 문장만 한 번 더 받아 적는다. - 대안 언어는 영어 우선. 확률 순으로 고르면 일본어가 뽑혀 가타카나 음차가 되고 확률도 높아 거를 수 없었다. - 평균 log 확률이 크게 떨어지면(진짜 한국어를 영작한 경우) 버린다. - 대안에 한글이 섞이면(small 이 언어를 못 바꾼 경우) 버린다. - 압축률 2.4 초과(반복 환각)면 버린다. 결과: small·turbo(beam 1/2) 모두 억양 영어 10/10 영어로, 한국어 6/6 유지, 원어민 영어·무전 가공 음성은 그대로. Co-Authored-By: Claude Opus 5.5 --- src/livesub/core/engine.py | 1 + src/livesub/models/asr.py | 113 +++++++++++++++++++++++++++- tests/test_asr_language.py | 146 +++++++++++++++++++++++++++++++++++++ tests/test_pipeline.py | 2 +- tests/test_speech_level.py | 2 +- 5 files changed, 258 insertions(+), 6 deletions(-) create mode 100644 tests/test_asr_language.py diff --git a/src/livesub/core/engine.py b/src/livesub/core/engine.py index 0418502..902f5cc 100644 --- a/src/livesub/core/engine.py +++ b/src/livesub/core/engine.py @@ -272,6 +272,7 @@ class TranslationEngine: language=source_lang, fast=not segment.is_final, prompt=self._last_final_text if segment.is_final else "", + target_lang=mcfg.target_lang, ) asr_ms = int((time.perf_counter() - t0) * 1000) if not transcript.text: diff --git a/src/livesub/models/asr.py b/src/livesub/models/asr.py index 6d0a01a..2f3f7f0 100644 --- a/src/livesub/models/asr.py +++ b/src/livesub/models/asr.py @@ -3,16 +3,37 @@ from __future__ import annotations import logging +import re import threading -from dataclasses import dataclass +from dataclasses import dataclass, field import numpy as np -from ..constants import models_dir +from ..constants import LANGUAGE_CODES, models_dir from .tiers import AsrSpec log = logging.getLogger(__name__) +#: 번역 대상 언어로 감지됐을 때, 다른 언어로 다시 받아 적은 결과를 채택하는 기준. +#: 두 결과의 토큰당 평균 log 확률 차이(다시 받은 쪽 - 처음 쪽)가 이 값보다 커야 한다. +#: +#: 한국인 억양 영어는 Whisper 가 한국어로 감지해 "스나이퍼 온 더 루프탑" 처럼 +#: 소리 나는 대로 적는다. 영어로 다시 받으면 확률이 비슷하거나 더 높게 나온다 +#: (실측 차이 -0.35 ~ +0.32). 진짜 한국어를 영어로 받으면 엉뚱한 영작이 되며 +#: 확률이 크게 떨어진다 (turbo 실측 -0.79 이하). 그 사이에 둔다. +ALT_LANGUAGE_MAX_LOGPROB_DROP = -0.45 + +#: Whisper 가 반복 환각("お客様にお客様に…")을 판정할 때 쓰는 압축률 기준과 같다. +#: 반복 루프는 확률이 높게 나와서 log 확률만으로는 걸러지지 않는다. +MAX_COMPRESSION_RATIO = 2.4 + +#: 다시 받은 결과에 이 글자가 섞여 있으면 모델이 언어를 바꾸지 못한 것이다. +#: (진짜 한국어를 small 모델로 '영어로' 받으면 한글을 그대로 적는다.) +_SCRIPT = { + "ko": re.compile(r"[\uac00-\ud7a3\u3131-\u318e]"), + "ja": re.compile(r"[\u3040-\u30ff]"), +} + @dataclass class Transcript: @@ -20,6 +41,12 @@ class Transcript: language: str confidence: float = 0.0 duration_s: float = 0.0 + #: 토큰당 평균 log 확률. 언어 재판정에 쓴다. + avg_logprob: float = 0.0 + #: 구간 중 가장 높은 압축률. 높으면 같은 말을 반복하는 환각이다. + compression_ratio: float = 0.0 + #: 언어 감지를 했을 때의 언어별 확률 (지정했으면 비어 있다) + language_probs: dict[str, float] = field(default_factory=dict) class SpeechRecognizer: @@ -63,15 +90,48 @@ class SpeechRecognizer: language: str | None = None, fast: bool = False, prompt: str = "", + target_lang: str | None = None, ) -> Transcript: """오디오 한 덩어리를 텍스트로. `fast=True` 는 중간 결과용으로 beam search를 끄고 빠르게 돌린다. + + `language` 가 None(자동 감지)이고 `target_lang` 을 주면 감지 결과를 한 번 + 더 따진다. Whisper 는 말의 언어보다 **억양**을 보고 언어를 고르는 경향이 + 있어서, 한국인이 말한 영어를 한국어로 감지하고 소리 나는 대로 한글로 적는다. + 그러면 원문과 번역 언어가 같아져 번역도 건너뛰고, 자막에는 "에너미 커밍 + 프롬더 레프트" 가 뜬다. 그래서 지원 언어 밖이거나 번역 대상 언어로 감지되면 + 다른 지원 언어로 한 번 더 받아 적고, 그쪽이 자연스러우면 채택한다. """ if self._model is None: self.load() assert self._model is not None + first = self._run(audio, language, fast, prompt) + if language is not None or fast or not first.text: + return first + + supported = first.language in LANGUAGE_CODES + if supported and first.language != target_lang: + return first + + alt_lang = _alternative_language(first.language_probs, first.language, supported) + if alt_lang is None: + return first + alt = self._run(audio, alt_lang, fast, prompt) + if not alt.text or alt.compression_ratio > MAX_COMPRESSION_RATIO: + return first + # 지원하지 않는 언어로는 어차피 번역할 수 없으므로 그때는 더 따지지 않는다. + if supported and not _accept_alternative(first, alt, first.language): + return first + log.debug("언어 재판정: %s -> %s (%r)", first.language, alt.language, alt.text) + alt.language_probs = first.language_probs + return alt + + def _run( + self, audio: np.ndarray, language: str | None, fast: bool, prompt: str + ) -> Transcript: + assert self._model is not None with self._lock: segments, info = self._model.transcribe( audio.astype(np.float32, copy=False), @@ -84,12 +144,57 @@ class SpeechRecognizer: vad_parameters={"min_silence_duration_ms": 300}, word_timestamps=False, ) - parts = [s.text for s in segments] + segments = list(segments) - text = " ".join(p.strip() for p in parts if p.strip()).strip() + text = " ".join(s.text.strip() for s in segments if s.text.strip()).strip() + tokens = sum(len(getattr(s, "tokens", ()) or ()) for s in segments) + logprob = ( + sum(s.avg_logprob * len(getattr(s, "tokens", ()) or ()) for s in segments) / tokens + if tokens + else 0.0 + ) + probs = getattr(info, "all_language_probs", None) or [] return Transcript( text=text, language=getattr(info, "language", language or "") or "", confidence=float(getattr(info, "language_probability", 0.0) or 0.0), duration_s=float(getattr(info, "duration", 0.0) or 0.0), + avg_logprob=float(logprob), + compression_ratio=max( + (float(getattr(s, "compression_ratio", 0.0) or 0.0) for s in segments), + default=0.0, + ), + language_probs={str(k): float(v) for k, v in probs}, ) + + +def _alternative_language( + probs: dict[str, float], detected: str, supported: bool +) -> str | None: + """다시 받아 적을 언어 하나. + + 번역 대상 언어로 잘못 감지된 경우는 거의 다 억양 섞인 영어라서 영어를 먼저 + 본다. 감지 확률 순으로 고르면 안 된다 — 한국인 억양 영어에 Whisper 는 영어보다 + 일본어를 높게 치기도 하는데, 일본어로 받으면 "スナイパーオン・ド・ループトップ" + 처럼 가타카나로 소리를 적고 확률도 높게 나와 걸러낼 방법이 없다. + + 지원하지 않는 언어로 감지됐을 때(광둥어 등)는 지원 언어 중 확률이 가장 높은 쪽. + """ + candidates = [c for c in LANGUAGE_CODES if c != detected] + if supported: + return "en" if "en" in candidates else _most_likely(candidates, probs) + return _most_likely(candidates, probs) + + +def _most_likely(candidates: list[str], probs: dict[str, float]) -> str | None: + known = [c for c in candidates if c in probs] + return max(known, key=lambda c: probs[c]) if known else None + + +def _accept_alternative(first: Transcript, alt: Transcript, avoided: str) -> bool: + if not alt.text: + return False + script = _SCRIPT.get(avoided) + if script is not None and script.search(alt.text): + return False + return alt.avg_logprob - first.avg_logprob > ALT_LANGUAGE_MAX_LOGPROB_DROP diff --git a/tests/test_asr_language.py b/tests/test_asr_language.py new file mode 100644 index 0000000..d00b547 --- /dev/null +++ b/tests/test_asr_language.py @@ -0,0 +1,146 @@ +"""억양 때문에 언어를 잘못 감지했을 때 다시 받아 적는지 (모델 없이 가짜로).""" + +from __future__ import annotations + +from types import SimpleNamespace + +import numpy as np + +from livesub.models.asr import SpeechRecognizer +from livesub.models.tiers import AsrSpec + +AUDIO = np.zeros(16_000, dtype=np.float32) + + +def seg(text: str, logprob: float, tokens: int = 10): + return SimpleNamespace(text=text, avg_logprob=logprob, tokens=list(range(tokens))) + + +class FakeWhisper: + """언어별로 정해 둔 결과를 돌려준다. language=None 이면 `detected` 로 감지한 척.""" + + def __init__( + self, + detected: str, + probs: dict[str, float], + results: dict[str, tuple], + ratios: dict[str, float] | None = None, + ): + self.ratios = ratios or {} + self.detected = detected + self.probs = probs + self.results = results + self.calls: list[str | None] = [] + + def transcribe(self, audio, language=None, **_): + self.calls.append(language) + lang = language or self.detected + text, logprob = self.results.get(lang, ("", 0.0)) + info = SimpleNamespace( + language=lang, + language_probability=self.probs.get(lang, 1.0), + duration=1.0, + all_language_probs=list(self.probs.items()) if language is None else None, + ) + segment = seg(text, logprob) + segment.compression_ratio = self.ratios.get(lang, 1.2) + return iter([segment]), info + + +def recognizer(fake: FakeWhisper) -> SpeechRecognizer: + rec = SpeechRecognizer(AsrSpec("fake", "int8", 1, 0), device="cpu") + rec._model = fake + return rec + + +# 실제 측정값을 그대로 옮겼다 (large-v3-turbo, 한국어 TTS 음성이 영어를 읽음). +ACCENTED = FakeWhisper( + "ko", + {"ko": 0.97, "en": 0.02, "ja": 0.005}, + {"ko": ("스나이퍼 온 더 루프타프, 노스 사이드.", -0.252), + "en": ("Sniper on the rooftop North side.", -0.487)}, +) + + +def test_korean_accented_english_is_rewritten_in_english(): + t = recognizer(ACCENTED).transcribe(AUDIO, target_lang="ko") + assert t.language == "en" + assert t.text == "Sniper on the rooftop North side." + + +def test_english_is_tried_even_when_japanese_scores_higher(): + """small 모델 실측: 일본어 확률이 영어보다 높지만 일본어로 받으면 가타카나 음차가 된다.""" + fake = FakeWhisper( + "ko", + {"ko": 0.77, "ja": 0.13, "en": 0.07, "zh": 0.01}, + {"ko": ("스나이퍼 온 더 루프탑, 노스 사이드.", -0.505), + "ja": ("スナイフォンとループタップ、ノスサイド。", -0.509), + "en": ("Sniper on the rooftop, Northside.", -0.363)}, + ) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert (t.language, t.text) == ("en", "Sniper on the rooftop, Northside.") + assert fake.calls == [None, "en"] # 다시 받는 건 한 번뿐 + + +def test_repetition_loop_is_rejected(): + """반복 환각은 확률이 높게 나와서 압축률로 거른다.""" + fake = FakeWhisper( + "nn", + {"nn": 0.6, "en": 0.3}, + {"nn": ("hmm", -0.9), "en": ("the the the the the the the the the the the the", -0.1)}, + ratios={"en": 9.0}, + ) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert t.text == "hmm" + + +def test_real_korean_stays_korean(): + """진짜 한국어를 영어로 받으면 엉뚱한 영작이 되고 확률이 크게 떨어진다.""" + fake = FakeWhisper( + "ko", + {"ko": 1.0, "en": 0.0}, + {"ko": ("잘했어 다음 판도 가자.", -0.284), "en": ("Well done, next time.", -1.074)}, + ) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert (t.language, t.text) == ("ko", "잘했어 다음 판도 가자.") + + +def test_alternative_still_in_hangul_is_rejected(): + """작은 모델은 '영어로' 받으라 해도 진짜 한국어를 한글로 그대로 적는다.""" + fake = FakeWhisper( + "ko", + {"ko": 0.99, "en": 0.0}, + {"ko": ("잘했어 다음 판도 가자", -0.40), "en": ("잘했어 다음 판도 가자", -0.44)}, + ) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert t.language == "ko" + + +def test_no_second_pass_when_language_differs_from_target(): + fake = FakeWhisper("en", {"en": 0.99, "ko": 0.01}, {"en": ("Fall back now.", -0.2)}) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert t.language == "en" + assert fake.calls == [None] + + +def test_fixed_source_language_is_never_second_guessed(): + fake = FakeWhisper("ko", {}, {"ko": ("안녕", -0.1)}) + recognizer(fake).transcribe(AUDIO, language="ko", target_lang="ko") + assert fake.calls == ["ko"] + + +def test_partial_results_skip_the_second_pass(): + """중간 결과는 빨라야 한다. 확정 문장에서만 다시 따진다.""" + recognizer(ACCENTED).transcribe(AUDIO, fast=True, target_lang="ko") + assert ACCENTED.calls[-1] is None + + +def test_unsupported_language_falls_back_to_best_supported(): + """지원 언어가 아니면 번역을 못 하므로 지원 언어 중 가장 그럴듯한 쪽으로.""" + fake = FakeWhisper( + "nn", + {"nn": 0.5, "en": 0.3, "ko": 0.1}, + {"nn": ("Nice skot", -0.9), "en": ("Nice shot", -0.5)}, + ) + t = recognizer(fake).transcribe(AUDIO, target_lang="ko") + assert (t.language, t.text) == ("en", "Nice shot") diff --git a/tests/test_pipeline.py b/tests/test_pipeline.py index a7f6778..ad2e49d 100644 --- a/tests/test_pipeline.py +++ b/tests/test_pipeline.py @@ -55,7 +55,7 @@ class FakeRecognizer: def unload(self): pass - def transcribe(self, audio, language=None, fast=False, prompt=""): + def transcribe(self, audio, language=None, fast=False, prompt="", target_lang=None): return Transcript(text="hello world", language="en", confidence=0.99) diff --git a/tests/test_speech_level.py b/tests/test_speech_level.py index c0c4468..4a856cf 100644 --- a/tests/test_speech_level.py +++ b/tests/test_speech_level.py @@ -194,7 +194,7 @@ def _run(monkeypatch, tmp_path, level: str, source_text: str, source_lang: str) translator = _PoliteTranslator() class Recognizer: - def transcribe(self, audio, language=None, fast=False, prompt=""): + def transcribe(self, audio, language=None, fast=False, prompt="", target_lang=None): return Transcript(text=source_text, language=source_lang) lines = []