Künstliche Intelligenz offline nutzen

1. Einleitung

Viele Anwendungen der Künstlichen Intelligenz (KI) können nur im Internet genutzt werden, z.B. die meisten Bildgeneratoren (DALL-E, Midjourney), Sprachgeneratoren (ElevenLabs, Google Text to Speech, Lovo, Murf, NaturalReaders, etc.) und die GPT-Textgeneratoren der OpenAI, Inc., allen voran der GPT-Chatbot ChatGPT. »GPT« steht dabei für »Generativer vortrainierter Transformer«.

Für einige von ihnen kann zwar eine Software lokal auf dem Rechner oder Webserver installiert werden, die den Internet-Browser ersetzt. Aber sie identifiziert sich bei den zugehörigen Servern der KI über einen sogenannten API-Key. Man zahlt mit seinen Daten zum Nutzungsverhalten und bzw. oder mit einer geringen Gebühr pro Zugriff. Wird die Verbindung zum KI-Server getrennt, funktioniert die Anwendung nicht mehr.

Andere Textgeneratoren (Large Language Models) lassen sich dagegen ohne API-Key oder Registrierung kostenlos herunterladen und ohne Verbindung ins Internet zeitlich unbegrenzt nutzen. Auf dem eigenen Rechner (oder Webserver) können so auch vertrauliche Daten verarbeitet werden. Ein Nachteil ist die wesentlich langsamere Verarbeitungsgeschwindigkeit.

Im Folgenden werden die lokale Installation und Nutzung des Projekts GPT4All, des Bildgenerators Stable Diffusion und der Sprachtranskription Whisper beschrieben. Getestet habe ich die Installationen jeweils auf den Betriebssystemen Windows 11 Pro 22H2 und Linux Mint 21.2 Victoria.

Die Installation der drei genannten KI-Anwendungen unter Linux ist meist etwas kürzer und komfortabler als unter Windows. Allerdings installiert man Linux oft auf einem alten Windows-Rechner, dem man ein zweites Leben schenken möchte, mit wenig Arbeitsspeicher und alter Grafikkarte. Auf einem solchen Rechner laufen Anwendungen der Künstlichen Intelligenz entweder gar nicht oder sehr langsam. (Schaltet ein alter Laptop sich wegen Überhitzung ab, kann es helfen, einen Kühlakku darauf zu legen, während die KI rechnet.) Die Installation von Anwendungen der Künstlichen Intelligenz auf einem eigenen (gemieteten, virtuellen Linux-) Webserver ist möglich, unter Umständen jedoch bei der Verarbeitung vertraulicher Daten weniger sicher als die hier beschriebenen lokalen Varianten. Verfügt man über einen leistungsfähigen Rechner, auf dem sowohl Windows als auch Linux installiert sind (dual boot), ist das Linux-Betriebssystem die etwas einfachere Wahl. Aber auch unter Windows ist die Installation der hier vorgestellten Anwendungen nicht wesentlich schwerer.

Mein vorläufiges Fazit ist, dass es sich bei Whisper um ein ernstzunehmendes Werkzeug handelt, mit dem man Audioaufzeichnungen verschiedenster 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 verschiedenster Audioaufzeichnungen 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.

Stable Diffusion hat in seiner Grundeinstellung einige Schwierigkeiten mit menschlichen Gesichtern und Proportionen. Trotzdem kann die Bildgenerierung mittels auf verschiedenste Anwendungsbereiche optimierter Modelle zu einem Hobby werden, bei dem sich viel Zeit verbringen ließe. Aber auch, wenn man nur einige Bilder zum Auflockern einer Präsentation benötigt, ist Stable Diffusion eine gute Alternative zur Bildersuche im Internet. Aber da beim Erzeugen von Bildern in den seltensten Fällen vertrauliche Daten verarbeitet werden, ist die Online-Version von Stable Diffusion am Ende doch die komfortablere Wahl.

Die Sprachmodelle in GPT4All veranschaulichen durch ihre Fehler und Unzulänglichkeiten die Funktions­weise von Textgeneratoren. Sie sind längst nicht so leistungsfähig wie z.B. das Online-Sprachmodell ChatGPT. In ihrer jetzigen Form taugen sie nicht zum Strukturieren, Zusammenfassen oder Übersetzen von Texten, sondern bestenfalls zum Sammeln kreativer Ideen.
 

2. Voraussetzungen

Dieser Abschnitt beschreibt die gemeinsamen Grundlagen einer Installation von GPT4All, Stable Diffusion und Whisper. In jedem dieser Fälle müssen zuerst die folgenden Schritte auf dem eigenen Rechner nachvollzogen werden.
 

2.1. Kommandozeile statt grafischer Benutzeroberfläche

Die Möglichkeiten der Künstlichen Intelligenz entwickeln sich gerade sehr schnell und bringen immer neue Anwendungsmöglichkeiten und Datenformate hervor. Grafische Benutzeroberflächen zu programmieren und zu aktualisieren kostet Zeit, die man lieber zunächst für die inhaltliche Beschäftigung mit den raschen 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. Im Moment sind weitgehend vom Betriebssystem unabhängige grafische Benutzeroberflächen am leichtesten mit einem offline laufenden Webbrowser zu erreichen, wie im Fall der grafischen Benutzeroberfläche für Stable Diffusion.

Textgeneratoren haben hier den Vorteil, dass sie nur mit Text arbeiten. 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, 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 und Stable Diffusion sind in der Programmiersprache Python geschrieben. Auch GPT4All kann über eine in Python geschriebene Schnittstelle gesteuert werden. Kenntnisse in Python-Programmierung erleichtern die Nutzung der Text- bzw. Bildgeneratoren, 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.0 und 3.11.6.

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.6. 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«) die Konsole (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 in der Konsole 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 die Konsole 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 sudo 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. GPT4All, StableDiffusion, 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 vorbereitet für die Installation von GPT4All, Stable Diffusion und Whisper.
 

3. GPT4All

GPT4All ist nicht zu verwechseln mit dem Sprachmodell GPT-4 der OpenAI, Inc., sondern es wird von der US-amerikanischen Firma Nomic AI herausgegeben, welche quelloffene KI fördert.

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

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

Nun installieren wir GPT4All mit: pip install gpt4all

Falls uns das Programm anschließend auffordert, eine neuere Version von Python pip zu installieren, geht das mit:

python -m pip install --upgrade pip (Windows)
python3 -m pip install --upgrade pip (Linux)

Jetzt sind wir bereit für die Arbeit mit den Sprachmodellen und laden zunächst das einfachste verfügbare herunter: Orca Mini mit einer Größe von knapp 2 GB. Dazu erstellen wir im Projektverzeichnis »[Benutzer]/GPT4All/« eine Textdatei, nennen sie start.py und kopieren den folgenden Inhalt hinein:

from gpt4all import GPT4All
input = "Bonn is the capital city of which state?"
model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf")
output = model.generate(input, max_tokens = 35)
print(output)

Die Python-Befehle in der Textdatei werden abgearbeitet, indem man im Terminal GPT4All\start.py (Windows) bzw. GPT4All/start.py (Linux) eingibt und die Eingabetaste drückt. Je nach Wert für die Variable max_tokens erhält man sehr unterschiedliche Ergebnisse und es lohnt sich, damit zu experimentieren.

Wurde das Modell heruntergeladen und will man den Rechner nun vom Internet trennen, muss ab dem nächsten Aufruf die mittlere Zeile wie folgt ergänzt werden:

model = GPT4All("orca-mini-3b-gguf2-q4_0.gguf", allow_download = False)

Andernfalls bricht die Verarbeitung mit einer Fehlermeldung ab, wenn keine Verbindung ins Internet besteht. Sprachmodelle mit der Dateiendung .gguf können auch selbst heruntergeladen und im Verzeichnis »[Laufwerk:]\Users\[Benutzer]\.cache\gpt4all« (Windows) bzw. »/home/[Benutzer]/.cache/gpt4all« (Linux) abgelegt werden.

Der zweite Versuch ist ein knapp 4 GB großes Modell auf Deutsch. Dafür ändern wir diese beiden Zeilen:

input = "Bonn ist die Hauptstadt welches Landes?"
model = GPT4All("em_german_mistral_v01.Q4_0.gguf")

Das Ergebnis überzeugt nicht. Wir lassen die Frage auf Deutsch stehen und setzen noch einmal das Modell orca-mini-3b-gguf2-q4_0.gguf ein. Je nach Wert für max_tokens sind lustige Ergebnisse unter den Antworten.

Als dritten Versuch wählen wir ein mit mehr als 9 GB deutlich größeres Modell auf Deutsch. Es ist nicht in GPT4All enthalten, sondern es heißt »em_german_13b_v01.Q5_K_M.gguf« und muss heruntergeladen werden von:

https://huggingface.co/TheBloke/em_german_13b_v01-GGUF

Nach dem Herunterladen verschiebt man die Datei in das eben schon erwähnte Verzeichnis

»[Laufwerk:]\Users\[Benutzer]\.cache\gpt4all« (Windows) bzw. »/home/[Benutzer]/.cache/gpt4all« (Linux) und trägt in start.py ein:

model = GPT4All("em_german_13b_v01.Q5_K_M.gguf", allow_download = False)

Bis zu einer Antwort vergeht nun viel mehr Zeit und der Ventilator des Rechners hat hörbar mehr Arbeit. Dieses Modell tritt selbstsicherer auf als die vorangegangenen. Unabhängig von der Einstellung max_tokens behauptet es, Bonn sei die Hauptstadt von Deutschland. Nächster Versuch:

input = "Wer war John von Neumann?"

Antwort:

John von Neumann (1903-1957) ist einer der bedeutendsten Mathematiker des 20. Jahrhunderts und hat maßgeblich zur Entwicklung verschiedener Bereiche wie Quantenmechanik, Informatik und Spieltheorie beigetragen. Er war auch ein Pionier in den Bereichen Kernphysik und theoretische Biologie.

Von Neumanns Vater war Arzt und seine Mutter Lehrerin. Schon als Kind zeigte er großes Interesse an Mathematik, was sein Vater förderte. Nach dem Abitur studierte er zunächst Chemie an der Universität Berlin, wechselte aber bald zur Mathematik nach München. 1926 promovierte er in Budapest bei John von Neumann (sein Onkel), einem renommierten Mathematiker und Physiker.

Nach seiner Promotion arbeitete er als Assistent am Institute for Advanced Study in Princeton, New Jersey, wo er mit Albert Einstein zusammenarbeitete. 1930 wurde er Professor an der University of California, Berkeley. Während des Zweiten Weltkriegs war er am Manhattan Project beteiligt und spielte eine wichtige Rolle bei der Entwicklung der Atombombe.

Nach dem Krieg kehrte von Neumann nach Princeton zurück und setzte seine Forschungen fort. Er starb 1957 an einem Krebsleiden.

Von

Es ist beachtlich, wie viele zutreffende Informationen über dieses spezielle Thema im Sprachmodell gespeichert sind. Andererseits scheint deren Abruf nicht so vorhersehbar zu sein wie bei einer Datenbank, sondern ähnelt mehr freier Assoziation oder dem Bericht eines Menschen, der Gedächtnislücken und schlechte Konzentration mit plausiblen Erzählungen zu füllen versucht. Mit weniger Zeit, als ich mit dem Prüfen falscher Angaben verbracht habe, hätte ich einen wahrheitsgemäßeren Text schreiben können:

John von Neumanns Vater war kein Arzt, sondern Bankier und Anwalt. Über den Beruf seiner Mutter habe ich im Internet keine Angabe gefunden. Mathematikkurse besuchte er in Berlin und Zürich, nicht in München. Professor in Berkeley war er nie. Sein größter Geniestreich bestand darin, dass er sein eigener Onkel war und bei sich selbst promovierte? Ob das verlorene Wort auf der letzten Zeile seinen frühen Tod im Alter von 53 Jahren symbolisiert?
 

4. Stable Diffusion

Für Stable Diffusion gibt es eine grafische Benutzeroberfläche, die lokal im Webbrowser und ohne Verbindung ins Internet genutzt werden kann. Da wir im Webbrowser arbeiten werden und nicht mit dem Terminal direkt in Python, benötigen wir keine virtuelle Umgebung. Es genügt, ein Verzeichnis anzulegen und es beispielsweise »[Benutzer]/StableDiffusion/« zu nennen.

Die Installation für verschiedene Betriebssysteme ist hier beschrieben:
https://github.com/AUTOMATIC1111/stable-diffusion-webui#installation-and-running

Unter Windows habe ich die erste beschriebene Methode angewandt. Ich habe sd.webui.zip heruntergeladen und diese Datei anschließend in das Verzeichnis »[Benutzer]/StableDiffusion/« verschoben. Dort klickt man mit der rechten Maustaste auf sd.webui.zip und wählt im dann erscheinenden Kontextmenü per Linksklick mit der Maus »Alle extrahieren…«

Nun muss im Verzeichnis »[Benutzer]/StableDiffusion/sd.webui« erst das Skript update.bat gestartet werden. Nachdem dieses Skript vollständig durchgelaufen ist, startet man run.bat und wartet ebenfalls, bis es fertig ist.

Nach dem Starten des Skripts kann es jeweils sein, dass die Nachricht erscheint: Der Computer wurde durch Windows geschützt. Klickt man dann auf »Weitere Informationen => Trotzdem ausführen« öffnet sich jeweils das Terminal, in dem die Aktualisierung bzw. Installation der Webbrowser-Benutzeroberfläche abläuft. Am Ende schließt man per Drücken einer beliebigen Taste das Terminal wieder.

Der Installer lädt auch das Modell »v1-5-pruned-emaonly.safetensors« von https://huggingface.co/runwayml/stable-diffusion-v1-5/tree/main in das lokale Verzeichnis »[Benutzer]\StableDiffusion\sd.webui\webui\models\Stable-diffusion« herunter. Dort können weitere Modelle abgelegt werden. Ist die Grafikkarte des Rechners nicht leistungsfähig genug, erhält man die folgende Fehlermeldung:

Unter Windows ändert man dazu in der Datei »[Benutzer]\StableDiffusion\sd.webui\webui\webui-user.bat« die Zeile set COMMANDLINE_ARGS= in

set COMMANDLINE_ARGS=--precision full --no-half --skip-torch-cuda-test --use-cpu all

Die ersten beiden Argumente beugen Fehlermeldungen vor, dass eine CPU eine höhere Rechengenauigkeit besitzt als eine Grafikkarte und daher »halbe Genauigkeit« nicht liefern könne. Das dritte Argument überspringt die Suche nach der von der Firma Nvidia entwickelten CUDA-Programmierschnittstelle für Grafikkarten und das letzte Argument schaltet die Berechnungen in Stable Diffusion auf den Hauptprozessor um.

Unter Linux folgt man der zur Linux-Version auf dem eigenen Rechner gehörenden Installationsanleitung. Wird die Grafikkarte nicht von StableDiffusion unterstützt, ändert man in der Datei »[Benutzer]/StableDiffusion/stable-diffusion-webui/webui-user.sh« die Zeile #export COMMANDLINE_ARGS="" in

export COMMANDLINE_ARGS="--precision full --no-half --skip-torch-cuda-test --use-cpu all"

Zum Starten unter Windows doppelklickt man auf die Datei »[Benutzer]\StableDiffusion\sd.webui\run.bat« und unter Linux öffnet man die Konsole im Verzeichnis »[Benutzer]/StableDiffusion/stable-diffusion-webui/« und gibt dort ./webui.sh ein und bestätigt mit der Eingabetaste.

Das Titelbild zu diesem Artikel ist eine Collage mit Ergebnissen aus Stable Diffusion zu den Begriffen »Langohrwolkenschaf«, »Obstteller mit Zwiebelmuster« und »Lachsfuchs.« Möchte man realistischere Bilder erzeugen lassen, sollte man weniger experimentell sein und Stable Diffusion mit englischen Begriffen nutzen.

Für die Verwendung mit Stable Diffusion erzeugter Bilder in Präsentationen, sozialen Medien oder kommerziellen Produkten gilt eine sehr freizügige Lizenz. Wer ganz sicher gehen will, kann mit der Online-Version von Stable Diffusion arbeiten und eine kommerzielle Lizenz dafür erwerben. Wer nicht mit vertraulichen Daten arbeitet oder aus technischem Interesse die Offline-Version von Stable Diffusion nutzen möchte, ist bei der einfach zu bedienenden und schnellen Online-Version ohnehin besser aufgehoben.

 

5. Whisper

5.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.
 

5.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).
 

5.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.
 

5.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 einen Podcast auf Ukrainisch gewählt, der sich mit der Zukunft Künstlicher Intelligenz beschäftigt. Die Audiodatei habe ich per Klick auf »Download episode« von der folgenden Seite heruntergeladen:

https://podcastaddict.com/episode/153258633

Um Schwierigkeiten mit dem Leerzeichen im Dateinamen zu umgehen, habe ich die Datei »daily shit3_e16_ai.mp3« in »podcast.mp3« umbenannt und sie anschließend in das Projektverzeichnis »[Benutzer]/Whisper/« verschoben.

Nun startet man die Transkription auf Ukrainisch:

whisper Whisper/podcast.mp3 --fp16 False --model large --language Ukrainian --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 sein mit dem Verzeichnis, 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 kyrillischen 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/podcast.mp3 --fp16 False --model large --language Ukrainian --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«, »large-v1« und »large-v2«. Mitunter liefert das Modell »large-v2« eine genauere Transkription als »large«, das identisch ist mit »large-v3«. 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. 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.
 

6. Whisper als Diktiersoftware

Eine Diktiersoftware wandelt nicht nur eine Audiodatei in Text um, sie verfügt auch über 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.

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 hierfür gemacht ist. Nicht nur muss man jeden Sprachbefehl mit »suchen und ersetzen« sowie anderen Formatierungsbefehlen einer Textverarbeitungs-Software selbst nachbauen, es sinkt dann auch die Erkennungs­genauigkeit. Die Trainingsdaten von Whisper enthielten keine Sprachbefehle und das Wahrscheinlichkeitsmodell kann durcheinander kommen, wenn in Fließtexten normalerweise seltene Wörter wie Komma und Punkt sehr 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. Dann sollte man den Text noch einmal lesen, ggf. korrigieren und kann die diktierte E-Mail dann absenden.

Das folgende Programmbeispiel kann mit einem Aufruf mehrere Audiodateien nacheinander transkribieren. Mittels Textersetzungen wird es in Ansätzen zu einer Diktiersoftware.

Im Verzeichnis der virtuellen Umgebung für Whisper (siehe »5.4. Whisper starten«) legt man zwei Textdateien an: »Konstanten.py« und »Funktionen.py«. Diese Trennung des Programm-Kodes in zwei Teile dient der Übersichtlichkeit. In die Datei »Konstanten.py« kopiert man folgenden Python-Kode hinein:

# Definition von Konstanten

# Eingabeverzeichnis für zu transkribierende MP3-Dateien
INPUT_DIRECTORY = "D:\\Diktate\\Eingabe\\"

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

# Sprache der Transkription
LANGUAGE = "German"

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

# 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 8 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',
    ' 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',
    'bindestrich': 'Bindestrich',
    'Bindestricht': 'Bindestrich',
    'binde Strich': 'Bindestrich',
    'Binde Strich': 'Bindestrich',
    ' Bindestrich Leertaste ': '- ',
    'Euro': '€',
    'kommer': 'Komma',
    'schräglich': 'Schrägstrich',
    'Schräglich': 'Schrägstrich',
    'Zitat-Anfang': 'Zitat Anfang',
    'zittert Anfang': 'Zitat Anfang',
    'Zitat-Ende': 'Zitat Ende',
    'zittert Ende': 'Zitat Ende',
    'Zitat Endpunkt': 'Zitat Ende Punkt'
}

#abschließendes suchen und ersetzen von Diktierbefehlen, mit IS_WHITESPACE
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': '; ',
    'Zitat Anfang': ' »',
    'Punkt Zitat Ende': '.« A',
    'Zitat Ende Punkt': '«. A',
    'Zitat Ende': '« ',
    'Bindestrich': '-A',
    'Leertaste': ' ',
    'Komma': ', ',
    'Punkt': '. A'
}

Das Ein- und Ausgabeverzeichnis, wie auch alle anderen Einträge in dieser Datei, können individuell angepasst werden. In die Datei »Funktionen.py« kopiert man folgenden Python-Kode hinein:

import io
import os
import whisper
import Konstanten as const


# 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


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

    txt_path = srt_path[:-4] + ".txt"
    if os.path.isfile(txt_path):
        print(f"überspringe vorhandenen Text {txt_path}")
    else:
        no_line_breaks = ""
        line_number = 2

        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

        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])

        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(mp3_file):

    mp3_path = os.path.join(const.INPUT_DIRECTORY, mp3_file)
    mp3_file_without_extension = mp3_file[:-4]
    output_dir = os.path.join(const.OUTPUT_DIRECTORY, mp3_file_without_extension)
    if not os.path.isdir(output_dir):
        os.mkdir(output_dir)

    srt_path = os.path.join(output_dir, mp3_file_without_extension + ".srt")
    txt_path = os.path.join(output_dir, mp3_file_without_extension + ".txt")
    destination_path = os.path.join(output_dir, mp3_file)

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

    if os.path.isfile(destination_path):
        os.remove(destination_path)
    os.rename(mp3_path, destination_path)


# Hauptprogramm, das zunächst alle zu transkribierenden MP3-Dateien sucht

mp3_files = [f for f in os.listdir(const.INPUT_DIRECTORY)]
mp3_counter = 0
for mp3_file in mp3_files:
    if mp3_file[-4:].lower() == ".mp3":
        mp3_counter += 1
        transcribe(mp3_file)

print()
if mp3_counter == 0:
    print(f"Das Eingabeverzeichnis {const.INPUT_DIRECTORY} enthält keine MP3-Audiodateien.")
elif mp3_counter == 1:
    print("Eine MP3-Audiodatei wurde transkribiert.")
else:
    print(f"{mp3_counter} MP3-Audiodateien wurden transkribiert.")
print()

Diesen Programmkode können wir dort starten, wo wir ohnehin beginnen, Whisper auszuführen: beim Aktivieren der virtuellen Umgebung.

Unter Windows öffnen wir die Datei »Scripts\activate.bat« und fügen an ihrem Ende ein:

@echo on
python ./Whisper/Funktionen.py
@echo off

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

python3 ./Whisper/Funktionen.py

Nun aktivieren wir im Terminal die virtuelle Umgebung:

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

Soll unter Windows die Datei »Scripts\activate.bat« nicht über das Terminal gestartet werden, sondern per Doppelklick mit der Maus, muss zuvor darin der relative Pfad geändert werden, von »./Whisper/« zu »../«. Außerdem empfielt es sich dann, die Datei »Scripts\activate.bat« am Ende um den Befehl pause zu ergänzen, damit sich die Konsole nach erfolgter Transkription nicht automatisch schließt.