Whisper-Transkription offline nutzen

1. Einleitung

Viele Anwendungen der Künstlichen Intelligenz (KI) können nur im Internet genutzt werden, z. B. die Chatbots ChatGPT und Le Chat. Offline gibt es dazu zwar selten gleichwertige Alternativen, aber mit Abstrichen an Leistungsfähigkeit und Schnelligkeit können quelloffene KI-Modelle lokal genutzt werden, ohne dass Daten den eigenen Rechner verlassen.

Oder man kann eine Software, die den Internet-Browser bei der Nutzung von Online-Modellen ersetzt, lokal auf dem Rechner installieren. Sie identifiziert sich dann bei den zugehörigen Servern der KI über einen sogenannten API-Key. Man zahlt mit seinen Daten zum Nutzungsverhalten und / oder mit einer geringen Gebühr pro Zugriff. Wird die Verbindung zum KI-Server getrennt, funktioniert die Anwendung nicht mehr.

Sicherer für Datenschutz und Verfügbarkeit ist es jedoch, von Plattformen wie Hugging Face und Github ohne API-Key oder Registrierung Sprachmodelle kostenlos herunterladen. Auf dem eigenen Rechner lassen sie sich dann ohne Verbindung ins Internet zeitlich unbegrenzt nutzen. So können auch vertrauliche Daten verarbeitet werden. Ein Nachteil ist die wesentlich langsamere Verarbeitungsgeschwindigkeit.

In diesem Text werde ich mich nur mit einem Sprachmodell der Künstlichen Intelligenz beschäftigen, der im Jahr 2022 von dem US-amerikanischen Unternehmen OpenAI veröffentlichten Whisper-Spracherkennung. Getestet habe ich die Installationen jeweils auf den Betriebssystemen Windows 11 Pro 24H2 und Linux Mint 22.1 Xia.

Whisper ist eine Software, mit der man Audioaufzeichnungen in rund 100 Sprachen zu Text transkribieren kann. Die von älterer Diktiersoftware bekannte Trainingsphase mit der eigenen Stimme entfällt ebenso wie eine Datenverarbeitung in der Cloud. Außerdem ermöglicht Whisper eine Übersetzung von Audioaufzeichnungen in allen diesen Sprachen nach Englisch in hoher Qualität. Neben der allgemeinen Langsamkeit von Sprachmodellen auf Alltags-Hardware hat Whisper den Nachteil, keine Diktiersoftware zu sein. Befehle wie »Zitat Anfang« oder »neuer Absatz« kennt es nicht. Mit der Funktion »Suchen und Ersetzen« in einer beliebigen Textverarbeitungssoftware oder mit etwas Geschick im Programmieren können die erkannten Texte jedoch nachbearbeitet werden.
 

2. Voraussetzungen

Dieser Abschnitt beschreibt gemeinsame Grundlagen einer Installation von Whisper und von Sprachmodellen mit Chat-Funktionen, wie sie z. B. auf Hugging Face zu finden sind. Auch wer mit diesen großen Spachmodellen experimentieren möchte, findet in diesem Abschnitt einige Grundlagen.
 

2.1. Kommandozeile statt grafischer Benutzeroberfläche

Die Möglichkeiten des Maschinellen Lernens entwickeln sich schnell und bringen immer neue Anwendungsmöglichkeiten und Datenformate hervor. Grafische Benutzeroberflächen dafür zu programmieren und zu aktualisieren kostet Zeit, die man lieber zunächst für die inhaltliche Beschäftigung mit diesen technischen Fortschritten verwendet. Eine Benutzeroberfläche zu bauen, die auf verschiedenen Betriebssystemen gleichermaßen gut läuft, ist bis heute keine triviale Aufgabe. Beim Lösen auch dieses Problems kann KI über die nächsten Jahre voraussichtlich hilfreich sein.

Textgeneratoren haben den Vorteil, dass sie nur mit Text arbeiten. Daher lassen sie sich auch ohne grafische Benutzeroberfläche gut nutzen. Ein Programm, das Texte einlesen und ausgeben kann, hatten Computer schon, als grafische Anwendungsfenster noch nicht erfunden waren. Dieses Terminal, auch Konsole oder Eingabeaufforderung genannt, gibt es bis heute in allen Betriebssystemen. Damit werden wir arbeiten.

Unter Windows öffnet man das Terminal mit der Tastenkombination Windows + R. Das blendet das kleine Fenster zum Ausführen eines Programms ein. Dort hinein tippt man entweder cmd oder wt (nur Windows 11) und bestätigt mit der Eingabetaste. Unter Linux öffnet man das Terminal mit der Tastenkombination Strg + Alt + T.

Ein weiterer Weg zum Öffnen des Terminals ist es, im Datei-Explorer das Kontextmenü zu nutzen. Dazu klickt man mit der rechten Maustaste auf eine freie Stelle (d.h. wo keine Datei und kein Verzeichnis ist) und wählt dann »In Terminal öffnen« (Windows) bzw. »Im Terminal öffnen« (Linux). Das ist praktisch, wenn man ein Kommando in das Terminal eingeben möchte, das sich auf eine Datei bezieht, die in dem Verzeichnis liegt, das der Datei-Explorer gerade anzeigt. Sonst müsste der ganz Verzeichnispfad bis zur Datei mit in das Terminal getippt werden.

Zum Schließen des Terminals gibt man Alt + F4 oder exit ein. Unter Linux funktioniert auch Strg + D. In der Suche findet man das Terminal unter den Begriffen »Terminal« oder »Eingabeaufforderung«. In beiden Betriebssystemen kann das Terminal auch über das entsprechende Symbol im Startmenü geöffnet und per Mausklick auf das kleine Kreuz am oberen rechten Fensterrand wieder geschlossen werden.

Das Terminal in Windows 11 hat in der Titelzeile einen kleinen, nach unten zeigenden Pfeil. Der Einfachheit halber wählen wir dort »Eingabeaufforderung« aus, nicht »Windows Power Shell« oder »Azure Cloud Shell«. Dort unter »Einstellungen« lässt sich die Ergabeaufforderung als »Standardprofil« setzen. Ganz unten in den Einstellungen muss dann noch »Speichern« angeklickt werden.

Wir werden das Terminal oft brauchen und können es nach dem ersten Öffnen direkt an die Taskleiste heften. Dazu klickt man mit der rechten Maustaste auf dessen Symbol mit dem >_ (Windows) bzw. $_ (Linux) im schwarzen Rechteck und klickt dann mit der linken Maustaste auf »An Taskleiste anheften« (Windows) bzw. »An der Leiste anheften« (Linux).

Wir werden im Verzeichnis des gegenwärtig auf dem Computer angemeldeten Benutzers arbeiten. Falls das Terminal ein anderes Verzeichnis anzeigt, macht man mit cd %userprofile% (Windows) bzw. cd / (Linux) das Benutzerverzeichnis zum Arbeits­verzeichnis.
 

2.2. Python

Whisper ist in der Programmiersprache Python geschrieben. Kenntnisse in Python-Programmierung erleichtern die Nutzung solcher Textgeneratoren, sind aber nicht unbedingt erforderlich.

Welche Version von Python auf dem Rechner installiert ist, findet man heraus, indem man im Terminal python --version (Windows) bzw. python3 --version (Linux) eingibt und mit der Eingabetaste bestätigt. Benötigt wird eine Python-Version zwischen 3.8 und 3.11.

In Linux ist Python schon enthalten. Sollte dem nicht so sein, kann Python im Terminal mit dem Befehl sudo apt install python3 oder in der grafischen Anwendungsverwaltung unter dem Suchwort Python3 installiert werden.

Gibt Windows eine Fehlermeldung aus wie »Python konnte nicht gefunden werden« oder öffnet sich der Windows Store, muss Python installiert werden. Dann aber am besten nicht aus dem Windows Store, sondern direkt von https://www.python.org/downloads/

Bitte achten Sie darauf, nicht den neuesten Python-Installer zu nehmen, sondern maximal die Version 3.11. Höhere Versionen unterstützt Whisper bisher nicht. Innerhalb der jeweiligen Version wählt man am besten den »Windows installer (64-bit)«.

Idealerweise prüft man nach dem Herunterladen die Echtheit des Installers anhand seiner MD5-Prüfsumme am Ende der Download-Seite. Es könnte ja sein, dass Hacker in den Installer nachträglich einen Virus eingebaut haben oder dass einfach das Herunterladen der Datei vorzeitig abgebrochen ist. Wem die geschätzten 99% Sicherheit genügen, dass auch ohne diesen Schritt alles gut geht, kann ihn überspringen.

Unter Linux führt die Paketverwaltung die Integritätsprüfung automatisch im Hintergrund aus und der Benutzer muss nichts dafür tun. Wer unter Windows die Integritätsprüfung nicht überspringt, öffnet im Verzeichnis mit dem heruntergeladenen Installer (meist »Downloads«) das Terminal (im Kontextmenü nach einem Klick mit der rechten Maustaste, siehe 2.1.), gibt certutil -hashfile python-3.11.6-amd64.exe md5 ein und bestätigt mit der Eingabetaste. Wurde ein anderer Installer gewählt, muss der Name der zu prüfenden Datei entsprechend angepasst werden.

Die im Terminal angezeigte Prüfsumme markiert man anschließend mit der Maus und kopiert sie mit Strg + C in die Zwischenablage. Auf der Download-Seite des Python-Installers sucht man im Browser nach dieser Zeichenkombination mit Strg + C dann Strg + V. Wird die Prüfsumme gefunden und steht in der Zeile, die zu dem heruntergeladenen Installer gehört, ist die Überprüfung erfolgreich und der Installer kann verwendet werden.

Zum Start der Python-Installation unter Windows doppelklickt man auf den Installer und setzt im Installationsdialog ganz unten noch das Häkchen bei »Add python.exe to PATH«. Um Python auch für andere Windows-Benutzerkonten verfügbar zu machen, klickt man auf »Customize installation«, »Next« und setzt ganz oben das Häkchen bei »Install Python 3.xx for all users«. Nach Klick auf »Install Now« bzw. »Install« bittet Windows, die Installation mit Klick auf »Ja« zu bestätigen. Hat man das getan und erhält man die Nachricht »Setup was successful«, kann das Installations­fenster geschlossen werden.

Vor der ersten Verwendung von Python muss das Terminal einmal geschlossen und neu geöffnet werden.
 

2.3. Python pip

Um in Python geschriebene KI-Anwendungen auf den Rechner herunterzuladen, wird der Paketmanager »Python pip« benötigt. Mit ihm verhält es sich anders herum als mit der Installation von Python selbst: unter Windows wurde »Python pip« durch den Python-Installer schon mit installiert, unter Linux fehlt es unter Umständen.

Um herauszufinden, ob Python pip auf dem Rechner installiert ist und falls ja, in welcher Version, gibt man im Terminal pip --version ein und betätigt anschließend die Eingabetaste.

Falls Python pip unter Linux noch fehlt, ist im Terminal apt install python3-pip einzugeben und mit der Eingabetaste zu bestätigen. Anschließend muss das Benutzerpasswort eingegeben und die Installation mit J und Eingabetaste noch einmal bestätigt werden.
 

2.4. Virtuelle Python-Umgebung

Arbeitet man an mehreren Python-Projekten zugleich, ist es nützlich, sie logisch von einander zu trennen. Denn zwischen Projekten, die nichts mit einander zu tun haben, möchte man nicht die Versionsnummern aller verwendeten Programmbibliotheken abgleichen müssen. Stürzt ein Projekt ab, will man nicht, dass dieser Fehler Auswirkungen auf andere Projekte hat. Deshalb gibt es in Python virtuelle Umgebungen. Auf die virtuelle Python-Umgebung verzichten kann nur, wer kurz etwas ausprobieren möchte und Python anschließend wieder deinstalliert (also fast niemand).

Unter Linux muss im Terminal apt install python3-venv eingegeben und mit der Eingabetaste bestätigt werden. Anschließend ist das Benutzerpasswort einzugeben und die Installation mit J und Eingabetaste noch einmal zu bestätigen. In Windows wurde »venv« schon gemeinsam mit Python installiert.

In dem nun folgenden Beispiel ist »[Benutzer]« der Name des Benutzerverzeichnisses unterhalb von »[Laufwerk:]\Users« (Windows) bzw. »/home« (Linux). Häufig, aber nicht immer, ist er identisch mit dem Login-Namen. »[Projekt]« ist im folgenden Beispiel der Name eines Python-Projekts, z. B. Whisper oder MeinTestProjekt.

Eine virtuelle Umgebung in Windows richtet man im Terminal mit dem folgenden Befehl ein: python -m venv [Laufwerk:]\Users\[Benutzer]\[Projekt]

In Linux lautet der Befehl: python3 -m venv /home/[Benutzer]/[Projekt]

Startet man ein Terminal mit jeder anderen Methode als aus dem Kontextmenü eines Verzeichnisses heraus (siehe 2.1.), ist das Benutzerverzeichnis schon als das aktuelle Arbeitsverzeichnis voreingestellt. Dann genügt zum Anlegen einer neuen virtuellen Umgebung der Befehl python -m venv [Projekt] (Windows) bzw. python3 -m venv [Projekt] (Linux). Wenige Sekunden nach Drücken der Eingabetaste ist die neue Umgebung eingerichtet.

Vor jeder Benutzung muss die virtuelle Umgebung aktiviert werden. Das geschieht mit [Projekt]\Scripts\activate (Windows) bzw. source [Projekt]/bin/activate (Linux).

Nun steht der Name des Projekts (der virtuellen Umgebung) in Klammern links vor der Eingabeaufforderung und die hier eingegebenen Befehle bleiben ohne Auswirkung auf andere Python-Projekte. Wieder verlassen kann man die virtuelle Umgebung mit dem Befehl deactivate oder durch Schließen des Terminals.

Nun ist der Rechner für die Installation von Whisper oder beliebiger anderer Sprachmodelle vorbreitet.
 

2.5. CUDA

Wessen Rechner keine CUDA-fähige Grafikkarte von NVIDIA hat, kann diesen Abschnitt überspringen. Alle Daten liegen dann im Arbeitsspeicher (RAM) oder ausgelagert auf der Festplatte, Berechnungen werden ausschließlich auf dem Hauptprozessor (CPU) durchgeführt.

CUDA (Compute Unified Device Architecture) ist eine von NVIDIA entwickelte Programmierschnittstelle, mit der hochgradig parallelisierbare Berechnungen auf einem Grafikprozessor (GPU) abgearbeitet werden können. Die statistischen Modelle Künstlicher Intelligenz sind parallelisierbar, so dass es einen deutlichen Schnelligkeitsgewinn bedeutet, wenn man über einen Computer mit ausreichend CUDA-Rechenleistung verfügt.

Es ist eine Grundvoraussetzung, damit CUDA funktioniert, den Treiber der Grafikkarte aktuell zu halten, entweder über die NVIDIA-Treiberverwaltung oder die des Betriebssystems.

Große Sprachmodelle haben mehrere »Schichten«, von denen auch nur ein Teil auf den CUDA-fähigen Grafikprozessor ausgelagert werden kann, während die übrigen in CPU und RAM bleiben. Whisper hat nur eine »Schicht«, die entweder ganz in den RAM oder ganz in den vRAM des Grafikprozessors passen muss.

Die kleineren Whisper-Modelle einschließlich »medium« laufen mit 6 GB RAM (bzw. vRAM und CUDA), die »large«-Modelle benötigen 10 bis 12 GB RAM (bzw. vRAM und CUDA).
 

3. Whisper

3.1. Git

Der in der Programmiersprache Python geschriebene Programmkode für Whisper befindet sich auf https://github.com/openai/whisper.

Das Werkzeug der Wahl zum Herunterladen und Aktualisieren von Github-Quellkode ist die Software-Versionsverwaltung Git. Welche Version von Git auf dem Rechner installiert ist, findet man heraus, indem man im Terminal git --version eingibt und mit der Eingabetaste bestätigt. Erscheint die Fehlermeldung, dass »git« nicht gefunden wurde, muss es installiert werden.

Unter Linux erfüllt der Befehl apt install git diesen Zweck. Er ist mit der Eingabetaste zu bestätigen. Anschließend muss das Benutzerpasswort eingegeben und die Installation mit J und Eingabetaste noch einmal bestätigt werden.

Für Windows kann Git von https://git-scm.com/download/win heruntergeladen werden. Den anderen Installer dort für das Winget-Tool benötigen wir nicht.

Der Windows-Installer wird mit Doppelklick gestartet. Als verifizierter Herausgeber muss Johannes Schindelin angezeigt werden. Ist das der Fall, kann die Installation mit Klick auf »Ja« bestätigt werden. Alle Voreinstellungen des Installers können mit »Next« durchgeklickt und beibehalten werden. Ist die Installation beendet, schließt der Installer sich selbstständig.
 

3.2. FFmpeg

Zum Einlesen von Audiodateien benötigt Whisper das quelloffene Multimedia-Softwarepaket »FFmpeg«. Welche Version davon auf dem Rechner installiert ist, findet man heraus, indem man im Terminal ffmpeg -version eingibt (hier nur mit einem – vor version) und mit der Eingabetaste bestätigt. Erscheint die Fehlermeldung, dass der Befehl »ffmpeg« nicht gefunden wurde, muss es installiert werden.

Unter Linux erfüllt der Befehl apt install ffmpeg diesen Zweck. Er ist mit der Eingabetaste zu bestätigen. Anschließend muss das Benutzerpasswort eingegeben und die Installation mit J und Eingabetaste noch einmal bestätigt werden. Alternativ kann dieses Paket in der grafischen Anwendungsverwaltung unter dem Suchwort Ffmpeg installiert werden.

Unter Windows benötigen wir ein weiteres Hilfsprogramm: Chocolatey. Für dessen Installation wird von der Seite https://chocolatey.org/install (ca. in der Mitte) folgender Befehl in die Zwischenablage kopiert:

Um den in die Zwischenablage kopierten Befehl auszuführen, suchen wir im Startmenü die Windows Power Shell (ohne den Zusatz ISE) und klicken mit der rechten Maustaste darauf. In dem nun erscheinenden Kontextmenü muss »Als Administrator ausführen« gewählt und mit Klick auf »Ja« bestätigt werden. In die Windows Power Shell hinein kopieren wir den Befehl und bestätigen ihn mit der Eingabetaste.

Ist die Installation von Chocolatey abgeschlossen, installieren wir FFmpeg. Der Befehl dazu kann in derselben Windows Power Shell wie eben ausgeführt werden:

choco install ffmpeg

Während der Installation von FFmpeg muss das Ausführen eines Skripts mit Druck auf die Taste Y erlaubt werden. Damit die Änderungen wirksam sind, müssen wir uns nach erfolgreicher Installationen aus Windows ausloggen und neu einloggen (ein Neustart des Rechners geht auch).
 

3.3. Whisper installieren

Jetzt legen wir mit dem Terminal eine virtuelle Umgebung an und aktivieren sie:

python -m venv Whisper (Windows) bzw. python3 -m venv Whisper (Linux)
Whisper\Scripts\activate (Windows) bzw. source Whisper/bin/activate (Linux).

Anschließend installieren wir Whisper mit: pip install git+https://github.com/openai/whisper.git

Unter Linux kann gegen Ende der Installation die Warnung erscheinen, dass das Installationsverzeichnis nicht in der Systemvariable PATH enthalten ist. Das Problem wird gelöst, indem man sich nach Ende der Installation abmeldet und neu anmeldet.
 

3.4. Whisper starten

Wir öffnen ein Terminal und aktivieren die virtuelle Umgebung:

Whisper\Scripts\activate (Windows) bzw. source Whisper/bin/activate (Linux).

Als Test für die Transkription habe ich den Begriff »Podcast über Künstliche Intelligenz« ins Koreanische übersetzen lassen und die Übersetzung dann in eine Suchmaschine kopiert. Aus den Suchergebnissen habe ich diesen offensichtlich populären Vortrag über Ethik Künstlicher Intelligenz gewählt:

https://www.youtube.com/watch?v=8dEqj7jvp4g

Die Audiodatei lädt man entweder mit einer geeigneten Software herunter oder man legt ein Diktiergerät neben den Lautsprecher. Die Aufzeichnung habe ich in »Vortrag.mp3« umbenannt und in das Projektverzeichnis »[Benutzer]/Whisper/« verschoben.

Nun startet man die Transkription auf Koreanisch:

whisper Whisper/Vortrag.mp3 --fp16 False --model large --language Korean --output_dir Whisper/output

Den nach rechts geneigten Trennstrich / versteht an dieser Stelle auch Windows. Das Argument --fp16 False beugt Fehlermeldungen vor, dass eine CPU eine höhere Rechengenauigkeit besitzt als eine Grafikkarte und daher »halbe Genauigkeit« nicht liefern könne. Gibt man kein Ausgabeverzeichnis an, speichert Whisper die Ergebnisse in dem Verzeichnis, von wo aus man im Terminal die Transkription gestartet hat. Dann vergisst man möglicherweise, wo die Ergebnisdateien liegen, wenn man das Terminal nach Ende der Transkription wieder geschlossen hat. Das Ausgabeverzeichnis muss nicht identisch mit dem Verzeichnis sein, wo die zu transkribierende Audiodatei sich befindet. Existiert das angegebene Verzeichnis zur Ausgabe nicht, legt Whisper es an.

Als Ergebnis erhält man u.a. eine Untertitel-Datei mit Zeitmarken und eine Datei nur mit dem erkannten Text. (Zur korrekten Darstellung der koreanischen Schrift müssen diese Dateien evtl. heruntergeladen werden oder man klickt im Browser auf »Ansicht => Textkodierung reparieren«.)

So startet man die Transkription mit gleichzeitiger Übersetzung zu Englisch:

whisper Whisper/Vortrag.mp3 --fp16 False --model large --language Korean --output_dir Whisper/output --task translate

Auch hier erhält man u.a. eine Untertitel-Datei mit Zeitmarken und eine Datei nur mit dem übersetzten Text.

Die anderen in Whisper verfügbaren Modelle sind »tiny«, »base«, »small«, »medium«, »turbo«, »large-v1« und »large-v2«. Mitunter liefert das Modell »large-v2« eine genauere Transkription als »large«, das identisch ist mit »large-v3«. Bei »turbo« handelt es sich um eine schnellere Version von »large-v3«. Dass auf Hugging Face »large-v2« wesentlich häufiger heruntergeladen wurde als »large-v3«, spricht für seine Qualität.

Jedes Sprachmodell wird bei seinem erstmaligen Start automatisch heruntergeladen und im Verzeichnis »[Laufwerk:]\Users\[Benutzer]\.cache\whisper« (Windows) bzw. »/home/[Benutzer]/.cache/whisper« (Linux) abgelegt. Hat man die Datei zuvor in ein anderes Verzeichnis heruntergeladen, teilt man das Whisper mit dem Kommandozeilenparameter --model_dir [Verzeichnis] mit.

Verzeichnisse und Dateien, deren Name mit einem Punkt beginnt, zeigt Linux normalerweise nicht an. Die Tastenkombinatioen Strg + H im Datei-Explorer blendet sie ein bzw. bei erneutem Drücken wieder aus.

Während der Transkription bleibt Whisper manchmal bei einem Satz stecken und wiederholt ihn mehrmals, bevor es weiter transkribiert. Es ist auch möglich, dass Whisper am Ende einer Transkiption einen Satz hinzu »halluziniert«. Insgesamt ist die Qualität der Spracherkennung jedoch sowohl in der Originalsprache als auch in Englisch sehr gut. Bisher kann Whisper in keine andere Sprache außer Englisch übersetzen, auch nicht nach Deutsch.

Eine vollständige Aufzählung aller Kommandozeilenoptionen befindet sich in der Datei https://github.com/openai/whisper/blob/main/whisper/transcribe.py zu Beginn und dann ab Zeile 513. Die Namen der von Whisper unterstützten Sprachen müssen, anders als in der Datei https://github.com/openai/whisper/blob/main/whisper/tokenizer.py, am Wortanfang groß geschrieben werden.
 

4. Whisper als Diktiersoftware

Eine Diktiersoftware wandelt nicht nur eine Audiodatei in Text um, sie hat auch Sprachbefehle, um den erkannten Text zu formatieren. Beispiele für Sprachbefehle sind neue Zeile, Komma, Punkt, Ausrufezeichen, Fragezeichen, Zitat Anfang und Zitat Ende. Die Zahl möglicher Sprachbefehle lässt sich fast ins Unendliche steigern, für runde, eckige und geschweifte Klammern, fetten, kursiven, unterstrichenen und durchge­strichenen Text, Groß- und Kleinschreibung, Einrückungen, Absätze, Tabellen usw.

Viele Versionen von Diktiersoftware verlangen eine ständige Internetverbindung und verarbeiten die Daten auf dem Server des Anbieters. Oder man lädt eine ausführbare Datei herunter, die dann ohne Verbindung ins Internet genutzt werden kann. Aber, besonders wenn sie kostenlos angeboten wird, ist nicht immer klar, ob diese Software Adware oder andere unerwünschte Funktionen enthält. Kommerzielle Offline-Diktiersoftware andererseits ist mit ihrer Lizenz an bestimmte Rechner gebunden. Sie kann auch noch andere Nachteile haben, z. B. dass sich der Rechner während der Transkription nicht mehr für andere Aufgaben nutzen lässt.

Whisper dagegen ist quelloffen und wird von vielen Menschen weltweit genutzt. Durch dieses »Mehraugenprinzip« ist das Risiko, dass Whisper Schadkode enthält, sehr gering. Wer wegen dieses Vorteils Whisper als Diktiersoftware nutzen möchte, steht vor dem Problem, dass Whisper nicht dafür gemacht ist. Jeden Sprachbefehl müsste man mit »suchen und ersetzen« sowie anderen Formatierungsbefehlen einer Textverarbeitungs-Software selbst nachbauen. Weil die Trainingsdaten von Whisper keine Sprachbefehle enthielten, kann das Wahrscheinlichkeitsmodell (vor allem bei Groß- und Klein­schreibung) kurz durcheinanderkommen, wenn in Fließtexten normalerweise seltene Wörter wie Komma und Punkt häufig auftreten.

Dennoch ist Whisper eine zeitsparende Methode, um z. B. E-Mails zu diktieren und sie nicht mehr per Hand tippen zu müssen. Zeitsparend in dem Sinn, dass man einige Minuten oder auch mal eine Stunde lang etwas anderes tut, bis Whisper die Transkription auf dem eigenen Rechner abgeschlossen hat. Den erkannten Text sollte man noch einmal lesen, ggf. korrigieren und kann die diktierte E-Mail dann absenden.

Das folgende Programmbeispiel kann mit einem Aufruf beliebig viele Audiodateien nacheinander transkribieren. Mittels automatischer Textersetzungen wird es zu einer einfachen Diktiersoftware.

Im Verzeichnis der virtuellen Umgebung für Whisper (siehe »3.4. Whisper starten«) legt man drei Textdateien an: »Konstanten.py«, »Transkribieren.py« und »Verschieben.py«. Diese Trennung des Programm-Kodes in mehrere Teile dient der Übersichtlichkeit.

In die Datei »Konstanten.py« kopiert man den folgenden Python-Kode hinein:

# Definition von Konstanten

# Ursprungsverzeichnis auf dem Diktiergerät
SOURCE_DIRECTORY = "E:\\MIC_A\\"

# Eingabeverzeichnis für zu transkribierende Audiodateien
INPUT_DIRECTORY = "D:\\Diktate\\Eingabe\\"

# Ausgabeverzeichnis für fertig transkribierte Audiodateien und ihre Transkripte
OUTPUT_DIRECTORY = "D:\\Diktate\\Ausgabe\\"

# 'cpu' zum Rechnen auf dem Hauptprozessor, 'cuda' zum Rechnen auf einer CUDA-fähigen Grafikkarte (wenn vorhanden)
DEVICE = 'cpu'

# Sprachmodell für die Transkription
MODEL = 'large-v2'

# Sprache der Transkription
LANGUAGE = 'German'

# Erweiterungen verarbeitbarer Audio- und Videodateien
ALLOWED_EXTENSIONS = {'.mp3', '.mp4', '.m4a', '.mpeg', '.mpga', '.flac', '.oga', '.ogg', '.wav', '.webm'}

# Wörter, die mit hoher Wahrscheinlichkeit in der Audiodatei vorkommen werden und die Whisper wiedererkennen soll
INITIAL_PROMPT = "Ausrufezeichen Bindestrich Doppelpunkt Fragezeichen Klammer Komma klein Leertaste Absatz Zeile Punkt Schrägstrich Semikolon Zitat"

# Zeichen vor oder nach einem zu ersetzenden Begriff, die mit dem Begriff gemeinsam ersetzt werden
IS_WHITESPACE = " -,."

# erstes Suchen und Ersetzen für das Buchstabieralphabet, insgesamt 16 Durchläufe mit IS_WHITESPACE,
# d.h. pro Zeile je einmal in Original- und einmal in Kleinschreibung
REPLACE_WITH_WHITESPACE_1 = {
    ' Groß ': ' A',
    'Groß ': ' A',
    ' Groß-': ' A',
    'Groß-': ' A',
    ' Klein ': ' a',
    'Klein ': ' a',
    ' Klein-': ' a',
    'Klein-': ' a'
}

# anschließendes einfaches Suchen und Ersetzen von Diktierbefehlen, ohne IS_WHITESPACE
REPLACE_NO_WHITESPACE = {
    'Anton ': 'A',
    'anton ': 'a',
    'Umlaut Anton ': 'Ä',
    'umlaut Anton ': 'ä',
    'Berta ': 'B',
    'berta ': 'b',
    'Bertha ': 'B',
    'bertha ': 'b',
    'Cäsar ': 'C',
    'cäsar ': 'c',
    'Dora ': 'D',
    'dora ': 'd',
    'Emil ': 'E',
    'emil ': 'e',
    'Friedrich ': 'F',
    'friedrich ': 'f',
    'Gustav ': 'G',
    'gustav ': 'g',
    'Heinrich ': 'H',
    'heinrich ': 'h',
    'Ida ': 'I',
    'ida ': 'i',
    'Julius ': 'J',
    'julius ': 'j',
    'Konrad ': 'K',
    'konrad ': 'k',
    'Ludwig ': 'L',
    'ludwig ': 'l',
    'Martha ': 'M',
    'martha ': 'm',
    'Nordpol ': 'N',
    'nordpol ': 'n',
    'Otto ': 'O',
    'otto ': 'o',
    'Umlaut Otto ': 'Ö',
    'umlaut Otto ': 'ö',
    'Paula ': 'P',
    'paula ': 'p',
    'Quelle ': 'Q',
    'quelle ': 'q',
    'Richard ': 'R',
    'richard ': 'r',
    'Siegfried ': 'S',
    'siegfried ': 's',
    'Theodor ': 'T',
    'theodor ': 't',
    'Ulrich ': 'U',
    'ulrich ': 'u',
    'Umlaut Ulrich ': 'Ü',
    'umlaut Ulrich ': 'ü',
    'Victor ': 'V',
    'victor ': 'v',
    'Viktor ': 'V',
    'viktor ': 'v',
    'Wilhelm ': 'W',
    'wilhelm ': 'w',
    'Xaver ': 'X',
    'xaver ': 'x',
    'Ypsilon ': 'Y',
    'ypsilon ': 'y',
    'Zeppelin ': 'Z',
    'zeppelin ': 'z',
    'binde-': 'Bindestrich',
    'bindestrich': 'Bindestrich',
    'bündestrich': 'Bindestrich',
    'Bindestricht': 'Bindestrich',
    'binde Strich': 'Bindestrich',
    'Binde Strich': 'Bindestrich',
    'Binde-Strich': 'Bindestrich',
    'Bündestrich': 'Bindestrich',
    'Bündesstrich': 'Bindestrich',
    ' Bindestrich Leertaste ': '- ',
    'Doppel, Punkt': 'Doppelpunkt',
    'Doppelfunkt': 'Doppelpunkt',
    'Euro ': '€ ',
    'Euro,': '€,',
    '? Fragezeichen': 'Fragezeichen',
    'Klammer Auf': 'Klammer auf',
    'Klammer Zu': 'Klammer zu',
    'kommer': 'Komma',
    'Lehrtaste': 'Leertaste',
    'schräglich': 'Schrägstrich',
    'schrägstrich': 'Schrägstrich',
    'Schräglich': 'Schrägstrich',
    'sie dort anfangen': 'Zitat Anfang',
    'sie hat angefangen': 'Zitat Anfang',
    'Zitatanfang': 'Zitat Anfang',
    'Zitternfang': 'Zitat Anfang',
    'Zitatsanfang': 'Zitat Anfang',
    'Zitat anfangen': 'Zitat Anfang',
    'Zitat, anfangen': 'Zitat Anfang',
    'Zitat, Anfang': 'Zitat Anfang',
    'Zitat-Anfang': 'Zitat Anfang',
    'Zitat. Anfang.': 'Zitat Anfang',
    'Zitat. Anfang': 'Zitat Anfang',
    'zittern Anfang': 'Zitat Anfang',
    'Zittern Anfang': 'Zitat Anfang',
    'Zittern anfangt': 'Zitat Anfang',
    'zitternd Anfang': 'Zitat Anfang',
    'Zitternanfang': 'Zitat Anfang',
    'zitternden Anfang': 'Zitat Anfang',
    'Zittert-Anfang': 'Zitat Anfang',
    'zittert anfangen': 'Zitat Anfang',
    'Zittert anfangen': 'Zitat Anfang',
    'zitiert Anfang': 'Zitat Anfang',
    'zittert Anfang': 'Zitat Anfang',
    'Zittert Anfang': 'Zitat Anfang',
    'zittert an von': 'Zitat Anfang',
    'zu dem Anfang': 'Zitat Anfang',
    'sie dort Ende': 'Zitat Ende',
    'Zitatende': 'Zitat Ende',
    'Zitatsende': 'Zitat Ende',
    'Zitternende': 'Zitat Ende',
    'Zitat-Ende': 'Zitat Ende',
    'Zitat. Ende': 'Zitat Ende',
    'Zitat, Ende': 'Zitat Ende',
    'zittern Ende': 'Zitat Ende',
    'Zittern Ende': 'Zitat Ende',
    'Zittert-Ende': 'Zitat Ende',
    'Zittertende': 'Zitat Ende',
    'zitiert Ende': 'Zitat Ende',
    'zittert Ende': 'Zitat Ende',
    'Zittert Ende': 'Zitat Ende',
    'Zitat. Endpunkt': 'Zitat Ende Punkt',
    'Zitat Endpunkt': 'Zitat Ende Punkt',
    'Zitat Endepunkt': 'Zitat Ende Punkt',
    'Zitat, Endepunkt': 'Zitat Ende Punkt',
    'Zittert-Endepunkt': 'Zitat Ende Punkt'
}

# abschließendes Suchen und Ersetzen von Diktierbefehlen, mit IS_WHITESPACE
# Der Befehl a bei Semikolon und Komma wirkt einem häufigen Erkennungsfehler entgegen,
# der das nachfolgende Wort immer groß schreibt und kann bei Bedarf gelöscht werden.
REPLACE_WITH_WHITESPACE_2 = {
    'Ausrufezeichen': '! A',
    'Doppelpunkt': ': ',
    'Fragezeichen': '? A',
    'ist gleich': '=',
    'Klammer auf': ' (',
    'Klammer zu:': '): ',
    'Klammer zu': ') ',
    'neuer Absatz': '\n\nA',
    'Neuer Absatz': '\n\nA',
    'neue Zeile': '\nA',
    'Neue Zeile': '\nA',
    'Schrägstrich': '/',
    'Semikolon': '; a',
    'Zitat Anfang': ' »',
    'Punkt Zitat Ende': '.« A',
    'Zitat Ende Punkt': '«. A',
    'Zitat Ende': '« ',
    'Bindestrich': '-A',
    'Leertaste': ' ',
    'Komma': ', a',
    'Punkt': '. A'
}

Das Ein- und Ausgabeverzeichnis, wie auch alle anderen Einträge in dieser Datei, müssen bzw. können individuell angepasst werden. Unter Linux müssen Ein- und Ausgabeverzeichnis in die dortige Schreibweise geändert werden, zum Beispiel "/home/[Benutzer]/Whisper/Eingabe/".

In die Datei »Transkribieren.py« kopiert man folgenden Python-Kode hinein:

import io
import re
import os
import whisper
import Konstanten as const
from datetime import datetime

# alle Vorkommen eines Diktierbefehls ersetzen und den geänderten Text zurückgeben
def search_and_replace_with_whitespace(text, find_phrase, replace_with):

    lower_or_upper_case = replace_with[-1:]
    if lower_or_upper_case == 'a' or lower_or_upper_case == 'A':
        replace_with = replace_with[:-1]
    else:
        lower_or_upper_case = '='

    text_position = text.find(find_phrase)
    phrase_length = len(find_phrase)

    while text_position >= 0:
        # zu ersetzende Zeichenkette nach links erweitern
        character_position = 0
        while text_position > 0 and character_position >= 0:
            character_position = const.IS_WHITESPACE.find(text[text_position - 1])
            if (character_position >= 0):
                text_position -= 1
                phrase_length += 1

        # zu ersetzende Zeichenkette nach rechts erweitern
        character_position = 0
        no_whitespace_right = True
        while text_position + phrase_length < len(text) and character_position >= 0:
            character_position = const.IS_WHITESPACE.find(text[text_position + phrase_length])
            if (character_position >= 0):
                phrase_length += 1
                no_whitespace_right = False

        if len(text) <= text_position + phrase_length:
            lower_or_upper_character = ''
        elif lower_or_upper_case == 'a':
            lower_or_upper_character = text[text_position + phrase_length].lower()
        elif lower_or_upper_case == 'A':
            lower_or_upper_character = text[text_position + phrase_length].upper()
        else:
            lower_or_upper_character = text[text_position + phrase_length]

        # 'Punkt' als Anfang eines längeren Wortes nicht durch '.' ersetzen
        if find_phrase == 'Punkt' and no_whitespace_right and lower_or_upper_character.isalpha():
            text_position = text.find(find_phrase, text_position + len(find_phrase))
        else:
            if len(text) > text_position + phrase_length + 1:
                text = text[:text_position] + replace_with + lower_or_upper_character + text[text_position + phrase_length + 1:]
            else:
                text = text[:text_position] + replace_with + lower_or_upper_character
            text_position = text.find(find_phrase, text_position + len(replace_with))

        phrase_length = len(find_phrase)

    return text

# mittels Regulärer Ausdrücke Zeitangaben wie "13 Uhr 30" finden und durch das Format "13:30 Uhr" ersetzen
def convert_time_format(text):

    pattern = re.compile(r'(\d{1,2}) Uhr (\d{1,2})')
    
    def replace_match(match):
        hour = match.group(1)
        minute = match.group(2)
        return f'{hour}:{minute.zfill(2)} Uhr'

    return re.sub(pattern, replace_match, text)

# alle Diktierbefehle ersetzen und das Ergebnis als Textdatei speichern
def search_and_replace_all(srt_path, txt_path):

    if os.path.isfile(txt_path):
        print(f"überspringe vorhandenen Text {txt_path}")
    else:
        no_line_breaks = ""
        line_number = 2

        # Untertitel-Datei ohne Zeitmarken und Zeilenumbrüche in eine Textvariable umkopieren
        with io.open(srt_path, encoding='utf-8') as lines:
            for line in lines:
                if line_number % 4 == 0:
                    if no_line_breaks == "":
                        no_line_breaks = line.strip()
                    else:
                        no_line_breaks += " " + line.strip()
                line_number += 1

        # für reine Transkription ohne Diktierbefehle die folgenden drei for-Blöcke entfernen
        for key in const.REPLACE_WITH_WHITESPACE_1:
            no_line_breaks = search_and_replace_with_whitespace(no_line_breaks, key, const.REPLACE_WITH_WHITESPACE_1[key])
            no_line_breaks = search_and_replace_with_whitespace(no_line_breaks, key.lower(), const.REPLACE_WITH_WHITESPACE_1[key])

        for key in const.REPLACE_NO_WHITESPACE:
            no_line_breaks = no_line_breaks.replace(key, const.REPLACE_NO_WHITESPACE[key])

        for key in const.REPLACE_WITH_WHITESPACE_2:
            no_line_breaks = search_and_replace_with_whitespace(no_line_breaks, key, const.REPLACE_WITH_WHITESPACE_2[key])

        no_line_breaks = convert_time_format(no_line_breaks)

        # Ergebnis-Datei speichern
        with io.open(txt_path, 'w', encoding='utf-8') as text:
            print(no_line_breaks.strip(), file=text)


# eine Audiodatei in Whisper zu transkribieren ist flexibler mit der Kommandozeile als direkt in Python
def transcribe(audio_file):

    return_value = True
    audio_path = os.path.join(const.INPUT_DIRECTORY, audio_file)
    audio_file_without_extension = os.path.splitext(audio_file)[0]
    output_dir = os.path.join(const.OUTPUT_DIRECTORY, audio_file_without_extension)
    if not os.path.isdir(output_dir):
        os.mkdir(output_dir)

    srt_path = os.path.join(output_dir, audio_file_without_extension + '.srt')
    txt_path = os.path.join(output_dir, audio_file_without_extension + '.txt')
    destination_path = os.path.join(output_dir, audio_file)

    print()
    if os.path.isfile(srt_path):
        print(f"überspringe vorhandenes Transkript {srt_path}")
        search_and_replace_all(srt_path, txt_path)
    else:
        print(f"transkribiere Audiodatei {audio_path}")
        print()
        command_line = f"whisper \"{audio_path}\" --device {const.DEVICE} --fp16 False --model {const.MODEL}"
        command_line += f" --language {const.LANGUAGE} --initial_prompt \"{const.INITIAL_PROMPT}\""
        command_line += f" --output_dir \"{output_dir}\" --verbose True --output_format srt"
        os.system(command_line)
        if os.path.isfile(srt_path):
            search_and_replace_all(srt_path, txt_path)
        else:
            return_value = False
            print("FEHLER: das Transkript wurde nicht gespeichert.")

    if os.path.isfile(destination_path):
        os.remove(destination_path)

    if return_value:
        os.rename(audio_path, destination_path)

    return return_value

# Hauptprogramm, das in einer 'unendlichen' Schleife alle zu transkribierenden Audiodateien sucht
# und nachträgliches Hinzufügen oder Löschen von Audiodateien während der Transkription ermöglicht
if __name__ == "__main__":
    audio_counter = 0
    start = datetime.now()

    while True:
        success = False
        all_files = os.listdir(const.INPUT_DIRECTORY)
        audio_files = [file for file in all_files if os.path.splitext(file)[1].lower() in const.ALLOWED_EXTENSIONS]
        
        if audio_files:
            success = transcribe(audio_files[0])
            if not success:
                break
            audio_counter += 1
        else:
            success = True
            break

    end = datetime.now()
    elapsed = end - start
    print()

    if not success:
        print(f"Die Transkription wurde nach {elapsed} wegen eines Fehlers abgebrochen.")
    elif audio_counter == 1:
        print(f"Eine Audiodatei wurde in {elapsed} transkribiert.")
    elif audio_counter > 1:
        print(f"{audio_counter} Audiodateien wurden in {elapsed} transkribiert.")
    else:
        print(f"Das Eingabeverzeichnis {const.INPUT_DIRECTORY} enthält keine Audiodateien.")
    print()

Und in die Datei »Verschieben.py« kopiert man folgenden Python-Kode hinein:

import os
import shutil
from tqdm import tqdm
import Pfade as paths

# alle MP3-Dateien rekursiv sammeln
def find_mp3_files(source_directory):
    # Alle .mp3 und .MP3 Dateien im Quellverzeichnis sammeln (keine Unterordner)
    mp3_files = [
        f for f in os.listdir(source_directory)
        if os.path.isfile(os.path.join(source_directory, f)) and f.lower().endswith('.mp3')
    ]
    return mp3_files

# Dateien mit Fortschrittsanzeige verschieben
def move_files(file_list, source_directory, destination_directory):
    # sicherstellen, dass das Zielverzeichnis existiert
    os.makedirs(destination_directory, exist_ok=True)

    for filename in tqdm(file_list, desc="Verschiebe MP3-Dateien", unit="Datei"):
        src_path = os.path.join(source_directory, filename)
        dest_path = os.path.join(destination_directory, filename)
        try:
            shutil.move(src_path, dest_path)
        except Exception as e:
            print(f"Fehler beim Verschieben von {filename}: {e}.")

if __name__ == "__main__":
    if os.path.isdir(paths.SOURCE_DIRECTORY):
        mp3s = find_mp3_files(paths.SOURCE_DIRECTORY)
        if not mp3s:
            print("\nKeine MP3-Dateien auf dem Diktiergerät gefunden.\n")
        else:
            print("")
            move_files(mp3s, paths.SOURCE_DIRECTORY, paths.INPUT_DIRECTORY)
            if len(mp3s) == 1:
                print(f"\nEin Diktat erfolgreich verschoben.\n")
            else:
                print(f"\n{len(mp3s)} Diktate erfolgreich verschoben.\n")
    else:
        print("\nDas Diktiergerät ist nicht mit dem Rechner verbunden.\n")

Diese letzte Datei ist zum Transkribieren nicht erforderlich. Sie übernimmt das Verschieben neuer Audiodaten vom Diktiergerät in das Eingabeverzeichnis. Sie ist ein Beispiel, wie sich man sich ohne wesentliche Programmierkenntnisse ein kurzes Programm von einem Chatbot schreiben lassen kann. Wer das ausprobieren will, kann in einen Chatbot der eigenen Wahl die folgende Anweisung hinein kopieren und sollte dann einen ähnlichen Programmkode erhalten:

Schreibe ein Python-Programm mit folgenden Merkmalen:

– läuft in der Konsole, ohne grafische Benutzeroberfläche
– hat ein konstantes Eingabeverzeichnis
– hat ein konstantes Ausgabeverzeichnis
– verschiebt alle Audiodateien im Format mp3 (Groß- und Kleinschreibung der Dateierweiterung einbeziehen) aus dem Eingabeverzeichnis in das Ausgabeverzeichnis
– ignoriert alle Unterverzeichnisse
– ignoriert alle anderen Dateitypen
– existiert das Eingabeverzeichnis nicht, wird die Meldung ausgegeben: „Das Diktiergerät ist nicht an den Rechner angeschlossen.“
– werden im Eingabeverzeichnis keine mp3-Dateien gefunden, wird die Meldung ausgegeben: „Das Eingabeverzeichnis enthält keine mp3-Dateien.“
– existiert das Ausgabeverzeichnis nicht, wird es angelegt
– gibt es im Ausgabeverzeichnis schon eine Datei mit identischem Namen (auch Unterschiede in Groß- und Kleinschreibung als identisch betrachten), wird die betreffende Datei nicht verschoben und eine entsprechende Meldung ausgegeben
– mit Fortschrittsbalken
– wurde genau eine Datei erfolgreich verschoben, schreibe am Ende: „Eine Datei wurde erfolgreich verschoben.“
– wurde eine andere Anzahl Dateien erfolgreich verschoben, schreibe am Ende: „[Anzahl] Dateien wurden erfolgreich verschoben.“
 

Die Transkription lässt sich nun entweder etwas umständlich über das Terminal starten:

Whisper\Scripts\activate (Windows) bzw. source Whisper/bin/activate (Linux) und dann
python .\Whisper\Transkribieren.py (Windows) bzw. python3 ./Whisper/Transkribieren.py (Linux).

Oder man legt sich eine Verknüpfung auf dem Desktop an. Unter Windows bearbeitet man dazu die Datei »Whisper\Scripts\activate.bat« und fügt an ihrem Ende ein:

@echo on
python ../Transkribieren.py
@echo off
pause

Nach dem Speichern dieser Änderung (z. B. mit Strg + S) zieht man die Datei »activate.bat« bei gehaltener rechter Maustaste aus dem Datei-Explorer auf den Desktop und wählt in dem bei Loslassen der Maustaste erscheinenden Kontextmenü »Verknüpfung hier erstellen«. Optional kann dann noch mit Rechtsklick auf die Verknüpfung ein anderer Name vergeben und unter »Eigenschaften« ein anderes Symbol gewählt werden. Passende Symbolbilder zum Herunterladen sind unter anderem auf iconarchive.com zu finden.

Unter Linux öffnen wir die Datei »Whisper/bin/activate« und fügen an ihrem Ende ein:

python3 /home/[Benutzer]/Whisper/Transkribieren.py
read -n1 -r -p "Drücken Sie eine beliebige Taste . . ." key

Der Pfad zur Datei »Transkribieren.py« muss dabei individuell angepasst werden. Nun erstellen wir auf dem Desktop eine leere Textdatei und nennen sie »Whisper.desktop«. Dort hinein kopieren wir den folgenden Kode:

[Desktop Entry]
Encoding=UTF-8
Name=Whisper
Comment=Audiodateien transkribieren
Exec=bash /home/[Benutzer]/Whisper/bin/activate
Icon=/home/[Benutzer]/Whisper/Tatice-Cristal-Intense-Notepad-Bloc-notes-2.256.png
Terminal=true
Type=Application