A TTS frontend for the German inventories of the MBROLA project
txt2pho is one part of a system to generate German text-to-speech synthesis. As the name implies txt2pho can convert pure text input to a so-called phonem file. In a second step this file can be read by the program MBROLA to generate a sound file, e.g. in the WAV format, which then can by played by any audio player.
Since the purpose of txt2pho is work on German text files and presumeably the majority of its users are German speakers, the rest of this documentation is in German. Nonetheless the source files, all commits and most bug reports of this project are in English.
txt2pho ist Teil eines Systems zur computergestützten Sprachausgabe von deutschen Texten (TTS). Der Name suggeriert bereits, dass txt2pho in der Lage ist, reine Textdateien in sogenannte Phonem-Dateien umzuwandeln. Diese Dateien können in einem zweiten Schritt mit Hilfe des Programms MBROLA in Sounddateien, beispielsweise im WAV Format, umgewandelt und anschließend mit einem beliebigen Audioprogramm abgespielt werden.
Da der Sinn von txt2pho darin besteht, deutsche Texte als Sprache auszugeben, dürften die meisten seiner Nutzer deutschsprachig sein. Der Rest der Dokumentation ist daher in Deutsch. Dennoch ist Englisch die lingua franca der Programmentwicklung, weshalb alle Quelltexte, die Commits und die meisten Fehlerberichte auf Englisch sind.
Das Programm txt2pho wurde Mitte der 90er Jahre von einem Team von Forschern am Institut für Kommunikationsforschung und Phonetik der Universität Bonn als Teil des Projekts Hadifix entwickelt. Neben der Erforschung der wissenschaftlichen Grundlagen einer Synthese menschlicher Sprache war ein Ziel des Projekts auch die Entwicklung von Software, um eine solche Synthese in der Praxis durchführen zu können. Das Ergebnis im Bereich der Softwareentwicklung ist ein System, das ein - für die 90er Jahre - recht gutes Sprachergebnis erzielt.
Ohne besondere Anpassungen klingt txt2pho (mit Hilfe von mbrola und der Stimme mbrola-de2) so:
Da die Standardausgabe von mbrola eine wav-Datei ist, diese Beispiele jedoch mp3-codiert (und damit nur 1/10 in der Größe) sind, ist der Klang real sogar besser…
Gut ein Vierteljahrhundert später stellt sich die Frage, warum man eine so alte Software heute noch einsetzen, ja sogar weiterentwickeln sollte. Da heute jedes Smartphone mit (mindestens) einer App zur Sprachausgabe ausgeliefert wird, sich über den Apple/Google Play Store in Minutenschnelle weitere Programme mit diesem Zweck installieren lassen und diese Systeme in der Regel eine sehr gute, geschliffene Sprachausgabe ermöglichen, liegt diese Frage nah.
Bei diesen Systemen wird die gute Sprachqualität oft durch stark vernetzte, serverbasierte Ansätze erzielt, bei denen mit Hilfe von umfangreichen Audiobibliotheken aus Aufnahmen von Millionen von Nutzern durch rechenintensive neuronale Netze eine natürlich klingende Sprachausgabe erzeugt wird. Die hierbei eingesetzten Ressourcen und die zur Verfügung stehenden finanziellen Mittel sind enorm.
Trotz der jahrelangen Forschungsarbeit, die in das Projekt investiert wurde, liegt auf der Hand, dass ein Programm wie txt2pho nicht mit den Forschungsbudgets und Entwicklerteamgrößen der Sprachausgabe-Projekte internationaler Softwarekonzerne konkurrieren kann. Angesichts dieser offensichtlichen Schwächen stellt sich damit die relevante Frage anders: Was sind die Stärken von txt2pho?
- Flexibilität der Einsatzmöglichkeiten
Viele Systeme der Sprachausgabe werden auf ein bestimmtes Einsatzfeld hin optimiert, d.h. sie beherrschen das Vokabular in diesem Bereich fehlerfrei und elegant. Bleibt der Einsatz auf diesen Bereich beschränkt, sind eng fokussierte Ansätze für Nutzer eine gute Lösung.
Sollen jedoch beliebige Texte - von allgemeinen Zeitungsartikeln, über Webseiten und Blogeinträgen bis hin zu eMails, wissenschaftlichen Aufsätzen oder ganzen Büchern - in Sprache umgewandelt werden, scheitern Systeme mit einem engen Fokus vielfach in einer Weise, dass die Sprachausgabe nicht nur schwieriger, sondern völlig unverständlich wird. Wenn bei einem flexiblen Eingangsvokabular Teile des Textes als sinnentstellte Laute ausgegeben werden, verschlechtern diese Fehler das Verständnis des Textes beim Hörer ungemein, was in Ausnahmefällen akzeptabel sein kann, bei einem wiederholten Auftreten das ganze System jedoch unbrauchbar macht.
Im Sinne der Einsatzflexibilität kommt txt2pho sehr gut mit Texten zurecht, die ein freies, nicht definiertes Vokabular verwenden, da selbst Fremdworte oder Neologismen in einer Weise ausgesprochen werden, die zwar falsch sein mag, aber verständlich bleibt. Dies ist der Grund, warum im deutschsprachigen Raum viele Sprachausgabe-Systeme und ScreenReader für Blinde txt2pho einsetzen. Aufgrund ihrer Sehbehinderung können Blinde bei einem Versagen der Sprachausgabe gerade nicht auf den Bildschirm schauen, um den Sinn des falsch ausgesprochenen Wortes zu identifizieren.
- Unverfälschtheit der Sprachausgabe
Die nicht übermäßig polierte Sprachausgabe von txt2pho hat zudem den direkten Vorteil, dass der Text so vorgelesen wird, wie er wirklich geschrieben ist. Jeder Fehler im Eingabetext, sei es ein klassischer Tippfehler, ein Endungsfehler oder ein fehlendes Komma, werden unmittelbar hörbar. Das System eignet sich also sehr gut zum Korrekturlesen von Texten.
- Stabilität des Projekts
Von unterschiedlichen Benutzergruppen - etwa Blinden - wird txt2pho seit Jahrzehnten zur Sprachausgabe genutzt, oft täglich über mehrere Stunden. Das Programm ist im regelmäßigen Einsatz extrem stabil und ausgetestet.
- Datenschutz und Datensouveränität
Alle Daten im Prozess der Sprachgenerierung werden lokal, ohne Netzwerk- oder Serveranbindung erzeugt. txt2pho kann somit problemlos offline in einer abgeschotteten Umgebung verwendet werden - die verarbeiteten Daten verlassen diese zu keinem Zeitpunkt. Forderungen nach Datensicherheit und dem Schutz eigener und fremder Daten lassen sich somit deutlich einfacher erfüllen als in einem cloud-basierten, weltweit verteilten Servernetzwerk. Die Souveränität über die verarbeiteten Daten geht niemals verloren - ein Aspekt, der vor allem in Geschäftsbereichen mit erhöhten Datenschutzanforderungen wie Krankenhäusern, Ärzten, Rechtsanwälten und Journalisten wichtig ist.
Selbst in einem System zur Heimautomation kann es wünschenswert sein, die ausgegebenen Meldungen nicht durch einen Cloud-Dienstleister verarbeiten zu lassen, um so den Schutz der eigenen Privatsphäre zu gewährleisten.
Überdies stellt die Verfügbarkeit der vollständigen Quelltexte sicher, dass ein möglicher Nutzer sich einen differenzierten Überblick über die verwendeten Algorithmen verschaffen und so sicherstellen kann, dass in der Software keine Hintertüren oder versteckten Abhörmöglichkeiten implementiert sind.
- Umweltschutz und Verbrauch der Ressourcen Energie/Wasser
Das Alter von txt2pho hat zudem den Vorteil, dass es zum Zeitpunkt der Entwicklung mit den damals verfügbaren Ressourcen an Rechen- und Speicherkapazität auskommen musste. Aus heutiger Sicht, 25 Jahre später, sind diese Anforderungen winzig - die Software lässt sich folglich auf nahezu jeder beliebigen Rechnerarchitektur und Systemgröße einsetzen. Ein ausgedienter Laptop kann ebenso zur Sprachausgabe genutzt werden wie ein Raspberry Pi, welche beide extrem günstig, oft sogar kostenlos verfügbar sind.
Dem Schutz der Umwelt ist durch dieses Recycling alter Hardware gedient. Die nicht benötigte Netzwerk- und vor allem Serveranbindung senken erheblich die Auswirkungen der Software auf die Umwelt, gehen cloud-basierte Ansätze doch regelmäßig mit einem erheblichen Einsatz der Ressourcen Energie und Wasser einher.
Zusammenfassend gibt es auf die Frage nach den Stärken von txt2pho eine Reihe von Antworten, die für den jeweiligen Nutzer und Einsatzzweck unterschiedlich relevant sind.
Gegenüber konkurrierenden Systemen sind die Vorteile von txt2pho
- die Flexibilität im Einsatz
- die Unverfälschtheit der Ausgabe
- Stabilität des Projekts
- der Schutz und die Souveränität über die genutzten Daten
- die Verfügbarkeit des gesamten Quellcodes
- die Schonung von Umweltressourcen
txt2pho wird nur in Form von Quelltexten bereitgestellt, da es einerseits sehr einfach ist, den Code in eine ausführbare Form zu übersetzen, andererseits das Programm auf einer Vielzahl höchst unterschiedlicher Plattformen benutzt werden kann. Da txt2pho im Prinzip nur ein Text-Konverter ist, der eine Texteingabedatei in in natürlicher Sprache in eine Textausgabedatei - die genannte PHO-Datei - umwandelt, ist hierfür lediglich ein c++-Compiler mit wenigen Standard-Libraries (aus der C++STD) erforderlich. Entwickelt wurde txt2pho (und die anderen Programme aus diesem Repository) mit GNU c/c++ 2.7, heute kommt hierfür GNU c/c++ 11.1 zum Einsatz.
Da im Laufe der Zeit c++ auf nahezu alle verfügbaren Hardware-Architekturen portiert wurde, dürfte auch txt2pho auf fast jeder beliebigen Plattform lauffähig sein, sofern genug Speicher zum Ausführen des Programms und zum Vorhalten der Lexika zur Verfügung steht. Nutzer haben txt2pho bereits auf sehr heterogenen Betriebssystemen wie Unix, MacOS, Sun und Windows eingesetzt und dabei so unterschiedliche Hardware wie Desktop PC, Laptops und Single-Board-Computer (etwa dem Raspberry Pi) genutzt. Gegenwärtig wird txt2pho unter Linux (Kubuntu 18.04) entwickelt.
Die Installation besteht im Wesentlichen aus dem Klonen des Repositorys, dem Compilen der Quellen und der Installation des auf das lokale System angepassten Settings.
Zum Compilieren wird ein c-Compiler und das Programm make benötigt. Sind beide noch nicht installiert, lässt sich dies schnell korrigieren - unter Ubuntu etwa mit dem Befehl.
sudo apt-get install make gccStehen der Compiler und make zur Verfügung, kann der Installationsprozess beginnen.
git clone https://github.com/GHPS/txt2pho.git
cd txt2pho
make clean
make allNach dem erfolgreichen Compilieren lassen sich die ausführbare Datei txt2pho (und die Hilfsprogramme preproc und pipeflt) direkt im obersten Projektordner aufrufen.
Jetzt gilt es noch, die Einstellungen an einen Ort zu kopieren, den txt2pho standardmäßig erwartet (etwa ~/.config), und diese Datei - vor allem die Pfade INVPATH und DATAPATH - auf die eigenen Gegebenheiten anzupassen.
cp settings/txt2phorc ~/.config/txt2phorc
vim ~/.config/txt2phorc (oder der eigene Editor)Dann steht einem ersten Test nichts mehr im Wege:
echo "Hallo Welt"|./txt2pho -m Dieser sollte folgendes Ergebnis liefern:
_ 10 0 86
h 75 25 87 52 88 79 90
a 81 5 92 30 94 54 96 79 97
l 38 8 99 61 100
o: 77 6 102 32 102 58 103 84 84
v 57 14 83 49 82 84 81
E 87 13 81 36 80 59 79 82 78
l 62 6 78 39 77 71 77
t 73 3 76 30 76
_ 483 2 85 6 85 10 85 14 85 18 85 23 85 27 85 31 85 35 85 39 85Glückwunsch! Jetzt lassen sich beliebige deutsche Texte in Phonem-Dateien konvertieren, die dann von MBROLA zu echten Audio-Dateien umgewandelt werden können.
Im zweiten Schritt sind noch das Programm MBROLA und eine Sprachdatei für die deutsche Sprache zu installieren. Wie beides geht, erklärt die mbrola Entwicklungsseite.
Zur Verbesserung der Sprachausgabe von txt2pho wurden Hilfsprogramme entwickelt, die die Eingabedatei zunächst als Filter aufbereiten. Von diesen Programmen ist heute nur noch die Nutzung von preproc sinnvoll (pipeflt diente schlicht der Entfernung von Zeilenumbrüchen, eine Funktion also, die auch in preproc enthalten ist).
Der Zweck von preproc ist es, die Eingabedatei zur Sprachausgabe dadurch vorzubereiten, dass eine Reihe von Regelsätzen angewandt wird und anschließend bekannte deutsche Abkürzungen in ihre Langform übersetzt werden. In den Regelsätzen kodiert ist die Aussprache von Zahlen und Brüchen, von Uhrzeiten und Daten und von eMail-Adressen.
Um preproc nutzen zu können, muss dem Programm zumindest die Regel-Datei mit Hilfe des Parameters -r übergeben werden, die Abkürzungsdatei kann dann - optional - nach dem Parameter -a folgen. Standardmäßig heißen die zu übergebenden Dateien preproc.rls (die Regel-Datei) und preproc.abk (die Abkürzungsdatei) und finden sich im Verzeichnis data. Anders als in Versionen vor 0.97 ist die Reihenfolge der Parameter beliebig.
Ein einfacher Test von preproc sieht so aus:
echo "1000 1/2 am 1.5.2021"|./preproc -r data/preproc.rls -a data/preproc.abkDie Ausgabe sollte lauten
ein tausend ein halb am 1n 5n zwei tausend einundzwanzig Die gute Nachricht ist dann: Auch preproc funktioniert!
Üblicherweise wird die Ausgabe von preproc direkt als pipe nach txt2pho weitergeleitet:
echo "1000 1/2 am 1.5.2021"|./preproc -r data/preproc.rls -a data/preproc.abk |./txt2pho -m _ 10 0 85
_ 33 58 85
aI 83 7 85 31 85 55 85 80 85
n 53 6 85 43 85 81 85
t 99 20 90 40 92
aU 105 10 94 30 96 49 97 68 99 87 101
z 28 21 102 93 103
@ 47 38 104 81 104
n 47 23 104 66 104
t 46 39 103
_ 28 64 103
aI 82 12 103 37 102 61 102 85 101
n 48 17 101 58 100 100 100
h 49 41 99 82 98
a 56 20 98 55 97 91 96
l 48 31 96 73 95
p 51 35 93
_ 24 67 92
a 57 21 93 56 95 91 96
m 48 31 98 73 100
...txt2pho erwartet eine Eingabedatei, in der die deutschen Umlaute nach ISO-8859-1 kodiert sind. Dieser Standard ist etwas in die Jahre gekommen, heutzutage werden viele Texte von Editoren, aber auch von der Shell in dem flexibleren und leistungsfähigeren UTF-8 kodiert. Deshalb ist es notwendig, entweder direkt den Editor auf diese Kodierung umzustellen oder die Eingabedatei selbst zu konvertieren. Beides ist recht einfach.
Unter Linux bietet sich zur Konvertierung das Tool iconv an, etwa in der Eingabepipe von txt2pho.
iconv -cs -f UTF-8 -t ISO-8859-1Aus einer pho-Datei, in der die Umlaute fehlen,
echo "Äpfel"|./txt2pho -m
_ 10 0 91
p 105 5 83 24 82 43 81
f 76 18 80 45 79 71 79 97 78
E 71 25 77 54 77 82 76
l 60 12 76 45 76 78 76
_ 483 1 85 6 85 10 85 14 85 18 85 22 85 26 85 30 85 35 85 39 85wird dann eine Datei mit korrekter Kodierung.
echo "Äpfel"| iconv -cs -f UTF-8 -t ISO-8859-1|./txt2pho -m
_ 10 0 89
_ 56 34 88 70 86
E 89 3 85 26 84 48 84 71 83 93 82
p 84 8 80 32 80
f 65 15 79 46 78 77 78
@ 52 10 77 48 76 87 76
l 55 24 76 60 76 96 76
_ 483 4 85 8 85 12 85 16 85 20 85 24 85 29 85 33 85 37 85 41 85 txt2pho (und preproc) ist recht genügsam, was die Version des verwendeten GCC-Compilers angeht. Jede Version, die in den letzten Jahrzehnten veröffentlich wurde, müsste eigentlich ausreichen. Getestet sind die Compiler-Versionen 7.5.0, 8.4.0 und 11.1. Mit letzterer Version wird aktuell entwickelt.
Um eine andere, ältere Version des c-Compilers zu verwenden, reicht es aus, dem make-Kommando die entsprechenden Versionen von CC (für den c-Compiler) und CPP (für den c++-Compiler) als Parameter zu übergeben. Natürlich muss diese Compiler-Version auch installiert sein und funktionieren.
make CC=gcc-8 CPP=g++-8Sowohl txt2pho als auch preproc bieten die Möglichkeit, durch das Aktivieren der Debugoption umfangreiche Fehler- und Debuginformationen zu bekommen. In beiden Fällen dient hierzu der Parameter -d, mit dem sich ein bestimmter Debuglevel setzen lässt. Standardmäßig ist der Debuglevel 0, d.h. keine Fehler- und Debuginformationen werden ausgegeben (was in Versionen vor 0.97 noch anders war). Je höher der Debuglevel, desto detaillierter sind die ausgegebenen Informationen.
Diese Informationen werden im Verzeichnis /tmp in Fehler- und Debugdateien gespeichert, die den Namen des Programms ergänzt um die PID bei Programmstart und die Erweiterung .log tragen. Die Dateien von txt2pho sind zusätzlich als debug- bzw. error-Dateien gekennzeichnet. Im tmp-Verzeichnis bleiben die Dateien bis zum Neustart des Systems erhalten.
cloc src
146 text files.
146 unique files.
3 files ignored.
github.com/AlDanial/cloc v 1.80 T=0.99 s (143.7 files/s, 76881.9 lines/s)
-------------------------------------------------------------------------------
Language files blank comment code
-------------------------------------------------------------------------------
C 23 4587 600 41859
C++ 45 1336 1368 21354
C/C++ Header 75 1361 884 3139
-------------------------------------------------------------------------------
SUM: 143 7284 2852 66352
-------------------------------------------------------------------------------Sie haben einen Fehler in txt2pho oder den beiliegenden Programmen gefunden und korrigiert? Super - teilen Sie bitte Ihre Arbeit mit dem Rest der Welt, damit dieses Projekt noch besser wird!
Verwenden Sie hierfür bitte das Pull Request System von Github.