Whisper Einrichtung: Self-Hosted Spracherkennung und Transkription

# Python virtuelle Umgebung
python3 -m venv whisper-env
source whisper-env/bin/activate

# Whisper installieren
pip install openai-whisper

# FFmpeg installieren (für Audioverarbeitung)
sudo apt-get install -y ffmpeg

# Grundlegende Transkription
whisper audio.mp3 --model medium --language German

# Übersetzung ins Englische
whisper audio.mp3 --model medium --task translate

# SRT-Untertitelformat
whisper audio.mp3 --model medium --language German --output_format srt

# Wortbasierte Zeitstempel
whisper audio.mp3 --model medium --language German --word_timestamps True

import whisper

# Modell laden
model = whisper.load_model("medium")

# Transkription
result = model.transcribe(
    "audio.mp3",
    language="de",
    task="transcribe",
    word_timestamps=True
)

print(result["text"])

for segment in result["segments"]:
    start = segment["start"]
    end = segment["end"]
    text = segment["text"]
    print(f"[{start:.2f} - {end:.2f}] {text}")

pip install faster-whisper

from faster_whisper import WhisperModel

# Modell laden (GPU)
model = WhisperModel(
    "large-v3",
    device="cuda",
    compute_type="float16"
)

# Für CPU-Modus
# model = WhisperModel("large-v3", device="cpu", compute_type="int8")

segments, info = model.transcribe(
    "audio.mp3",
    language="de",
    beam_size=5,
    word_timestamps=True,
    vad_filter=True
)

print(f"Erkannte Sprache: {info.language} (Wahrscheinlichkeit: {info.language_probability:.2f})")

for segment in segments:
    print(f"[{segment.start:.2f}s -> {segment.end:.2f}s] {segment.text}")

from fastapi import FastAPI, UploadFile, File
from faster_whisper import WhisperModel
import tempfile
import os

app = FastAPI(title="Whisper API")
model = WhisperModel("large-v3", device="cuda", compute_type="float16")

@app.post("/v1/audio/transcriptions")
async def transcribe(
    file: UploadFile = File(...),
    language: str = None,
    response_format: str = "json"
):
    with tempfile.NamedTemporaryFile(delete=False, suffix=os.path.splitext(file.filename)[1]) as tmp:
        content = await file.read()
        tmp.write(content)
        tmp_path = tmp.name
    
    try:
        segments, info = model.transcribe(tmp_path, language=language, beam_size=5, vad_filter=True)
        segments_list = list(segments)
        full_text = " ".join([s.text.strip() for s in segments_list])
        
        return {
            "text": full_text,
            "language": info.language,
            "duration": info.duration,
            "segments": [{"start": s.start, "end": s.end, "text": s.text.strip()} for s in segments_list]
        }
    finally:
        os.unlink(tmp_path)

@app.get("/health")
async def health():
    return {"status": "ok", "model": "large-v3"}

FROM nvidia/cuda:12.4.0-runtime-ubuntu22.04

RUN apt-get update && apt-get install -y \
    python3 python3-pip ffmpeg \
    && rm -rf /var/lib/apt/lists/*

WORKDIR /app
COPY requirements.txt .
RUN pip3 install --no-cache-dir -r requirements.txt
COPY whisper_api.py .

EXPOSE 9000
CMD ["uvicorn", "whisper_api:app", "--host", "0.0.0.0", "--port", "9000"]

version: '3.8'
services:
  whisper:
    build: .
    container_name: whisper-api
    ports:
      - "9000:9000"
    volumes:
      - whisper_cache:/root/.cache
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: 1
              capabilities: [gpu]
    restart: unless-stopped
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:9000/health"]
      interval: 30s
      timeout: 10s
      retries: 3

volumes:
  whisper_cache:

# Transkription mit Datei-Upload
curl -X POST http://localhost:9000/v1/audio/transcriptions \
  -F "file=@meeting.mp3" \
  -F "language=de"

# Automatische Spracherkennung
curl -X POST http://localhost:9000/v1/audio/transcriptions \
  -F "file=@audio.wav"

import requests

def transcribe_audio(file_path, language=None):
    url = "http://localhost:9000/v1/audio/transcriptions"
    with open(file_path, "rb") as f:
        files = {"file": f}
        data = {"language": language} if language else {}
        response = requests.post(url, files=files, data=data)
    return response.json()

result = transcribe_audio("meeting.mp3", language="de")
print(f"Text: {result['text']}")
print(f"Dauer: {result['duration']:.1f} Sekunden")

import os, glob
from faster_whisper import WhisperModel

model = WhisperModel("large-v3", device="cuda", compute_type="float16")
audio_files = glob.glob("audio_files/*.mp3") + glob.glob("audio_files/*.wav")

for audio_file in audio_files:
    print(f"Verarbeitung: {audio_file}")
    segments, info = model.transcribe(audio_file, language="de", vad_filter=True)
    output_file = os.path.splitext(audio_file)[0] + ".txt"
    with open(output_file, "w", encoding="utf-8") as f:
        for segment in segments:
            f.write(f"[{segment.start:.2f} - {segment.end:.2f}] {segment.text}\n")
    print(f"  Gespeichert: {output_file}")