180 lines
6.4 KiB
Python
180 lines
6.4 KiB
Python
"""faster-whisper-Engine.
|
|
|
|
Das Modell wird genau einmal geladen und danach fuer alle Dateien
|
|
wiederverwendet. Die Audiodateien werden von faster-whisper gestreamt
|
|
dekodiert, es wird nie eine komplette Sammlung in den RAM geladen.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import math
|
|
from pathlib import Path
|
|
from typing import Any
|
|
|
|
from ..config import TranscriptionConfig
|
|
from ..utils.logging import get_logger
|
|
from .models import TranscriptResult, TranscriptSegment, WordToken
|
|
|
|
logger = get_logger("transcription.engine")
|
|
|
|
|
|
class TranscriptionError(RuntimeError):
|
|
"""Fehler beim Laden des Modells oder beim Transkribieren."""
|
|
|
|
|
|
class FasterWhisperEngine:
|
|
"""Duenner Wrapper um :class:`faster_whisper.WhisperModel`."""
|
|
|
|
def __init__(
|
|
self,
|
|
settings: TranscriptionConfig,
|
|
*,
|
|
device: str | None = None,
|
|
compute_type: str | None = None,
|
|
model_dir: str | Path | None = None,
|
|
):
|
|
self.settings = settings
|
|
self.device = (device or settings.device).strip().lower()
|
|
self.compute_type = (compute_type or settings.compute_type).strip().lower()
|
|
self.model_dir = Path(model_dir) if model_dir else None
|
|
self._model: Any | None = None
|
|
|
|
# ------------------------------------------------------------------
|
|
@property
|
|
def model_name(self) -> str:
|
|
return self.settings.model
|
|
|
|
@property
|
|
def is_loaded(self) -> bool:
|
|
return self._model is not None
|
|
|
|
@property
|
|
def language(self) -> str | None:
|
|
return self.settings.language_for_whisper
|
|
|
|
# ------------------------------------------------------------------
|
|
def load(self) -> None:
|
|
"""Laedt das Modell (idempotent)."""
|
|
if self._model is not None:
|
|
return
|
|
|
|
# CUDA-Bibliotheken aus den pip-nvidia-Paketen verfuegbar machen, bevor
|
|
# CTranslate2 sie laedt (sonst: "libcublas.so.12 is not found").
|
|
if self.device == "cuda":
|
|
from ..system.gpu import ensure_cuda_libraries
|
|
|
|
ensure_cuda_libraries()
|
|
|
|
try:
|
|
from faster_whisper import WhisperModel
|
|
except ImportError as exc: # pragma: no cover - Installationsthema
|
|
raise TranscriptionError(
|
|
"faster-whisper ist nicht installiert. Bitte die Projektabhaengigkeiten installieren."
|
|
) from exc
|
|
|
|
download_root = str(self.model_dir) if self.model_dir else None
|
|
if download_root:
|
|
Path(download_root).mkdir(parents=True, exist_ok=True)
|
|
|
|
logger.info(
|
|
"Lade Whisper-Modell %s (device=%s, compute_type=%s)",
|
|
self.model_name,
|
|
self.device,
|
|
self.compute_type,
|
|
)
|
|
try:
|
|
self._model = WhisperModel(
|
|
self.model_name,
|
|
device=self.device,
|
|
compute_type=self.compute_type,
|
|
download_root=download_root,
|
|
)
|
|
except Exception as exc: # CTranslate2 wirft diverse RuntimeError
|
|
raise TranscriptionError(
|
|
f"Modell '{self.model_name}' konnte nicht geladen werden "
|
|
f"(device={self.device}, compute_type={self.compute_type}): {exc}"
|
|
) from exc
|
|
|
|
def unload(self) -> None:
|
|
self._model = None
|
|
|
|
# ------------------------------------------------------------------
|
|
def transcribe(self, path: str | Path) -> TranscriptResult:
|
|
"""Transkribiert eine Audiodatei vollstaendig."""
|
|
if self._model is None:
|
|
self.load()
|
|
assert self._model is not None
|
|
|
|
settings = self.settings
|
|
transcribe_kwargs: dict[str, Any] = {
|
|
"language": settings.language_for_whisper,
|
|
"beam_size": max(1, int(settings.beam_size)),
|
|
"word_timestamps": bool(settings.word_timestamps),
|
|
"vad_filter": bool(settings.vad_filter),
|
|
# Dialogpassagen nicht durch aggressive Stille-Erkennung abschneiden.
|
|
"condition_on_previous_text": False,
|
|
}
|
|
if settings.vad_filter:
|
|
transcribe_kwargs["vad_parameters"] = {
|
|
"min_silence_duration_ms": 700,
|
|
"speech_pad_ms": 300,
|
|
}
|
|
|
|
try:
|
|
segments_iter, info = self._model.transcribe(str(path), **transcribe_kwargs)
|
|
except Exception as exc:
|
|
raise TranscriptionError(f"Transkription fehlgeschlagen: {exc}") from exc
|
|
|
|
segments: list[TranscriptSegment] = []
|
|
text_parts: list[str] = []
|
|
|
|
try:
|
|
for segment in segments_iter:
|
|
words: list[WordToken] = []
|
|
for word in getattr(segment, "words", None) or []:
|
|
words.append(
|
|
WordToken(
|
|
word=word.word,
|
|
start=float(word.start),
|
|
end=float(word.end),
|
|
probability=getattr(word, "probability", None),
|
|
)
|
|
)
|
|
confidence = None
|
|
avg_logprob = getattr(segment, "avg_logprob", None)
|
|
if avg_logprob is not None:
|
|
# Nur als interne Gueteinformation, keine Wahrscheinlichkeit
|
|
# im Sinne der Suche.
|
|
try:
|
|
confidence = float(math.exp(float(avg_logprob)))
|
|
except (OverflowError, ValueError):
|
|
confidence = None
|
|
|
|
text = (segment.text or "").strip()
|
|
if text:
|
|
text_parts.append(text)
|
|
segments.append(
|
|
TranscriptSegment(
|
|
text=text,
|
|
start=float(segment.start),
|
|
end=float(segment.end),
|
|
confidence=confidence,
|
|
words=words,
|
|
)
|
|
)
|
|
except Exception as exc:
|
|
raise TranscriptionError(f"Fehler beim Lesen der Segmente: {exc}") from exc
|
|
|
|
full_text = " ".join(part for part in text_parts if part).strip()
|
|
duration = getattr(info, "duration", None)
|
|
language = getattr(info, "language", None) or settings.language_for_whisper
|
|
|
|
return TranscriptResult(
|
|
segments=segments,
|
|
full_text=full_text,
|
|
language=language,
|
|
language_probability=getattr(info, "language_probability", None),
|
|
duration=float(duration) if duration else None,
|
|
model=self.model_name,
|
|
)
|