Text-to-Speech unter Linux: Piper, Phonetik & Wiktionary-Integration   Vor kurzem aktualisiert!


Piper TTS spricht Ortsnamen
KI-generiertes Bild: Piper TTS spricht Ortsnamen

Wer Voice-Over für Home-Automation, Podcasts oder Tutorials sucht, landet oft bei Cloud-Anbietern. Doch mit Piper, einer schnellen, lokal laufenden TTS-Engine, und einer Prise Python lässt sich ein System bauen, das dank Wiktionary-Anbindung selbst schwierige Ortsnamen wie „Wermelskirchen“ perfekt ausspricht.

Hier ist der Weg von der Installation bis zum optimierten Workflow.

Installation: Piper & Stimmen

Piper ist in C++ geschrieben und extrem performant. Für die deutsche Sprache ist die Stimme von Thorsten (Thorsten-Voice) der Goldstandard.

Schritt 1: Piper installieren

Am einfachsten geht es via Python-Paketmanager (pipx wird empfohlen, um das System sauber zu halten):

pipx install piper-tts

Schritt 2: Stimmen-Modelle laden

Wir nutzen zwei Qualitätsstufen. Das medium-Modell ist schnell, das high-Modell bietet noch mehr Nuancen.

mkdir -p ~/piper-voices && cd ~/piper-voices
# Medium Modell
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/medium/de_DE-thorsten-medium.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/medium/de_DE-thorsten-medium.onnx.json

# High Modell (für finale Podcast-Qualität)
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/high/de_DE-thorsten-high.onnx
wget https://huggingface.co/rhasspy/piper-voices/resolve/main/de/de_DE/thorsten/high/de_DE-thorsten-high.onnx.json

Als schneller Workflow: Kommandozeilen-Aliase

Um nicht jedes Mal lange Befehle tippen zu müssen legt man Kurzbefehle in der .bashrc (oder .zshrc) an:

# Schnelltest (Ausgabe direkt über die Lautsprecher)
alias say='piper --model ~/piper-voices/de_DE-thorsten-medium.onnx --output_raw | aplay -r 22050 -f S16_LE -t raw'

# In Datei schreiben (High Quality)
alias render_hq='piper --model ~/piper-voices/de_DE-thorsten-high.onnx --output_file'

Anwendung: echo "Hallo Welt" | say oder echo "Text" | render_hq test.wav.

Weitere Idee: Ein Phonetik-Skript

Standard-TTS scheitert oft an Eigennamen oder Fachbegriffen. Die Lösung: Wir nutzen die IPA-Lautschrift (International Phonetic Alphabet) von Wiktionary.

Die Entscheidung: API vs. Scraping

In der Theorie bietet Wiktionary eine API. In der Praxis liefert diese oft nur unstrukturierten Wikitext oder extrem verschachteltes JSON zurück.

Die Lösung: Man nutzt gezieltes HTML-Scraping. Über den CSS-Selektor span.ipa lässt sich die exakte Aussprache eines Wortes viel zuverlässiger extrahieren.

Das Python-Skript (audio_gen.py)

Dieses Skript liest einen Text, prüft für jedes Wort, ob eine Lautschrift im lokalen Cache oder auf Wiktionary existiert, reichert den Text mit IPA-Tags ([[ ˈapfl̩ ]]) an und übergibt das Ergebnis an Piper.

#!/usr/bin/env python3
import requests
import re
import json
import os
import argparse
import subprocess

# --- KONFIGURATION ---
CACHE_FILE = "pronunciation_cache.json"
# Pfad zu deinem Thorsten-Voice Modell
MODEL_PATH = os.path.expanduser("~/piper-voices/de_DE-thorsten-high.onnx")

def get_ipa(word):
    """Holt die IPA-Lautschrift von Wiktionary via Scraping."""
    word_clean = word.strip().capitalize()
    url = f"https://de.wiktionary.org/wiki/{word_clean}"
    headers = {'User-Agent': 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64) TTS-Project'}
    
    try:
        r = requests.get(url, headers=headers, timeout=5)
        if r.status_code == 200:
            # Flexibler Regex für Parsoid-HTML (handhabt style/about Attribute)
            match = re.search(r'class="ipa"[^>]*>(.+?)</span>', r.text)
            if match:
                ipa = match.group(1).strip()
                # HTML-Tags entfernen
                ipa = re.sub(r'<[^>]+>', '', ipa)
                
                # Piper-Cleanup: Zeichen entfernen, die Warnungen auslösen
                # / [] sind Begrenzer, ͡ und ̯ sind Verbindungsbögen
                for char in ["/", "[", "]", "͡", "̯"]:
                    ipa = ipa.replace(char, "")
                
                # Nur die erste Aussprachevariante nehmen
                return ipa.split(",")[0].split(";")[0].strip()
    except Exception:
        pass
    return None

def process_text(text, cache):
    """Reichert den Text mit IPA-Tags für Piper an."""
    words = text.split()
    processed = []
    modifications = []

    for word in words:
        # Nur Satzzeichen am Rand entfernen, Umlaute behalten
        clean = word.strip(".,!?;:()\"' ")
        
        if len(clean) >= 2:
            if clean in cache:
                ipa = cache[clean]
                processed.append(f"[[ {ipa} ]]")
                modifications.append((clean, ipa, "Cache"))
            else:
                ipa = get_ipa(clean)
                if ipa:
                    cache[clean] = ipa
                    processed.append(f"[[ {ipa} ]]")
                    modifications.append((clean, ipa, "Wiktionary"))
                else:
                    processed.append(word)
        else:
            processed.append(word)
    
    return " ".join(processed), modifications

def main():
    parser = argparse.ArgumentParser(description="TTS mit Wiktionary-Support")
    parser.add_argument("input", help="Input Textdatei (.txt oder .md)")
    parser.add_argument("-o", "--output", default="output.wav", help="Name der Output-Datei")
    args = parser.parse_args()

    if not os.path.exists(args.input):
        print(f"Fehler: Datei {args.input} nicht gefunden.")
        return

    # UTF-8 ist Pflicht für Umlaute!
    with open(args.input, "r", encoding="utf-8") as f:
        content = f.read()

    # Cache laden (falls vorhanden)
    cache = {}
    if os.path.exists(CACHE_FILE):
        with open(CACHE_FILE, "r", encoding="utf-8") as f:
            cache = json.load(f)

    enriched_text, mods = process_text(content, cache)

    # Status-Ausgabe
    print(f"\n--- Analyse: {len(content.split())} Wörter verarbeitet ---")
    print(f"--- Davon {len(mods)} mit IPA-Lautschrift ersetzt ---")

    if mods:
        for m in mods:
            print(f"Anpassung: {m[0]} -> {m[1]} ({m[2]})")

    # Cache speichern (ensure_ascii=False macht die Datei lesbar!)
    with open(CACHE_FILE, "w", encoding="utf-8") as f:
        json.dump(cache, f, indent=4, ensure_ascii=False)

    # Piper Aufruf via Subprocess
    print("\n--- Generiere Audio ---")
    try:
        subprocess.run([
            "piper", "--model", MODEL_PATH, "--output_file", args.output
        ], input=enriched_text.encode('utf-8'), check=True)
        print(f"Erfolg! Datei gespeichert: {args.output}")
    except Exception as e:
        print(f"Fehler bei Piper: {e}")

if __name__ == "__main__":
    main()

Update vom 16. November 2026: Korrektur der Statusausgabe

Dank eines aufmerksamen Lesers aus der Schweiz wurde ein kleiner Fehler im Python-Skript audio_gen.py entdeckt.

In der ursprünglichen Version wurde innerhalb der Funktion main() auf die Variable words zugegriffen. Diese wird jedoch ausschließlich lokal in process_text() definiert und steht in main() nicht zur Verfügung.

Dadurch kam es beim Ausführen des Skripts zu einem NameError.

Die Statusausgabe wurde daher korrigiert und gleichzeitig erweitert:

print(f"\n--- Analyse: {len(content.split())} Wörter verarbeitet ---")
print(f"--- Davon {len(mods)} mit IPA-Lautschrift ersetzt ---")

Jetzt wird sowohl die Gesamtzahl der verarbeiteten Wörter als auch die Anzahl der vorgenommenen IPA-Ersetzungen angezeigt.

Vielen Dank für den freundlichen Hinweis und das aufmerksame Lesen!

Das Codebeispiel im Artikel wurde entsprechend aktualisiert.

Was dieses Skript macht:

  • UTF-8 Handling: Durch encoding="utf-8" beim Lesen und Schreiben gibt es keine Probleme mit Umlauten auf Linux-Servern.
  • Transparenter Cache: Dank ensure_ascii=False wird die JSON-Datei in echtem Text gespeichert und man kann sie einfach mit einem Editor öffnen und Wörter korrigieren, ohne kryptische Unicode-Codes (\u02c8) entziffern zu müssen.
  • Piper-Optimierung: Die automatische Entfernung der Ligaturbögen sorgt dafür, dass die Piper-Konsole während des Renderns sauber bleibt und keine Missing phoneme-Warnungen ausgibt.
  • Regex-Robustheit: Da Wiktionary oft zusätzliche Attribute in den HTML-Tags hat (z. B. style oder about), muss der Parser flexibel sein: re.search(r'class="ipa"[^>]*>(.+?)</span>', r.text).

Den Cache manuell tunen

Nach dem ersten Lauf wird eine pronunciation_cache.json angelegt. Da wir ensure_ascii=False nutzen, sieht sie in dieser Art aus:

{
    "Wermelskirchen": "ˈvɛʁml̩sˌkɪʁçn̩",
    "Nextcloud": "nɛkstklaʊd"
}

Hier kann man die Aussprache manuell verfeinern. Wenn „Thorsten“ ein Wort zu schnell spricht, fügt man einfach ein paar Zeichen ein oder ändert die Betonung.

Mit diesem Setup entsteht ein leistungsfähiges Werkzeug zur lokalen Sprachsynthese unter Linux. Durch die Kombination aus Piper, einer hochwertigen deutschen Sprachstimme und der automatischen IPA-Unterstützung über Wiktionary lässt sich insbesondere die Aussprache von Eigennamen und schwierigen Fachbegriffen gezielt verbessern. Der eigentliche Text-to-Speech-Prozess läuft vollständig lokal. Lediglich für die erstmalige Abfrage unbekannter Wörter aus Wiktionary ist eine Internetverbindung erforderlich. Bereits gespeicherte IPA-Einträge werden anschließend aus dem lokalen Cache geladen.Besonders praktisch: Die Aussprache einzelner Wörter lässt sich im Cache jederzeit manuell korrigieren und optimieren.

Tipp: Besonders bei Ortsnamen lohnt sich der Blick in den Cache, um die typische Betonung exakt zu treffen!