In diesem Beitrag stelle ich meine selbst entwickelte Anwendung vor, die Audiodaten aufzeichnet und mithilfe von OpenAIs Whisper-Modell in Text umwandelt. Die Anwendung nutzt eine grafische Benutzeroberfläche (GUI) basierend auf PyQt5 und bietet Funktionen wie Aufnahme, Transkription, Übersetzung und sogar das Vorlesen des Ergebnisses. Ich erkläre euch, wie ihr sie installiert, zeige den vollständigen Code und beschreibe, wie alles funktioniert.
Funktionen der Anwendung
- Audioaufnahme: Nimmt Sprache über ein Mikrofon in Echtzeit auf (maximal 20 Sekunden).
- Transkription: Wandelt die Aufnahme mit Whisper in Text um.
- Übersetzung: Kann die Aufnahme zusätzlich übersetzen (z. B. ins Englische).
- Vorlesen: Liest den transkribierten Text mit einer Text-to-Speech-Engine vor.
- Zwischenablage: Kopiert den Text in die Zwischenablage und fügt ihn bei Bedarf ein.
Voraussetzungen und Installation
Um die Anwendung auszuführen, müsst ihr einige Python-Bibliotheken und das Whisper-Modell installieren. Hier ist die Schritt-für-Schritt-Anleitung:
1. Python installieren
Stellt sicher, dass Python (mindestens Version 3.8) auf eurem System installiert ist. Ihr könnt es von python.org herunterladen.
2. Abhängigkeiten installieren
Öffnet ein Terminal und führt die folgenden Befehle aus, um die benötigten Python-Pakete zu installieren:
bash
pip install sounddevice numpy scipy pyttsx3 pyperclip pyautogui PyQt53. Whisper installieren
Das Whisper-Modell von OpenAI wird über ein Kommandozeilen-Tool integriert. Installiert es mit:
bash
pip install -U openai-whisperFalls ihr CUDA für GPU-Beschleunigung nutzen wollt (wie im Code vorgesehen), müsst ihr sicherstellen, dass CUDA auf eurem System installiert ist. Mehr dazu findet ihr auf der NVIDIA CUDA-Seite.
4. Mikrofon und Audio
Die Anwendung verwendet sounddevice für die Audioaufnahme. Stellt sicher, dass ein Mikrofon angeschlossen und als Eingabegerät ausgewählt ist.
Der vollständige Code
Hier ist der komplette Python-Code meiner Audio Transcriber-Anwendung:
python
import sys
import sounddevice as sd
import numpy as np
from scipy.io.wavfile import write
import os
import subprocess
import pyttsx3
import pyperclip
import pyautogui
from PyQt5.QtWidgets import (QApplication, QMainWindow, QPushButton, QTextEdit,
QLabel, QVBoxLayout, QWidget)
from PyQt5.QtCore import Qt, QThread, pyqtSignal
from PyQt5.QtGui import QFont
class AudioWorker(QThread):
finished = pyqtSignal(str)
status_update = pyqtSignal(str)
def __init__(self, fs):
super().__init__()
self.fs = fs
self.recording = False
self.buffer = []
def run(self):
self.audio_stream = sd.InputStream(samplerate=self.fs, channels=1, dtype='int16')
self.audio_stream.start()
while self.recording:
try:
audiodaten, _ = self.audio_stream.read(self.fs)
self.buffer.extend(audiodaten)
if len(self.buffer) > self.fs * 20:
self.stop_recording()
except Exception as e:
self.status_update.emit(f"Fehler: {str(e)}")
break
self.audio_stream.stop()
self.audio_stream.close()
buffer_array = np.array(self.buffer)
aufnahme_dateiname = "aufnahme.wav"
write(aufnahme_dateiname, self.fs, buffer_array)
self.status_update.emit("Verarbeite Aufnahme...")
inhalt = self.process_audio(aufnahme_dateiname)
self.finished.emit(inhalt)
def process_audio(self, aufnahme_dateiname):
try:
subprocess.run(f"whisper {aufnahme_dateiname} --device cuda --model medium --output_dir transkrip",
shell=True, check=True)
subprocess.run(f"whisper {aufnahme_dateiname} --device cuda --model medium --output_dir transl --task translate",
shell=True, check=True)
os.chdir("transkrip")
with open("aufnahme.txt", 'r', encoding='utf-8') as file:
return file.read()
except Exception as e:
return f"Fehler bei der Verarbeitung: {str(e)}"
def stop_recording(self):
self.recording = False
class AudioTranscriberWindow(QMainWindow):
def __init__(self):
super().__init__()
self.fs = 44100
self.worker = None
self.init_ui()
def init_ui(self):
self.setWindowTitle("Audio Transcriber")
self.setGeometry(100, 100, 600, 400)
# Haupt-Widget und Layout
central_widget = QWidget()
self.setCentralWidget(central_widget)
layout = QVBoxLayout(central_widget)
# Styling
self.setStyleSheet("""
QMainWindow { background-color: #f0f0f0; }
QPushButton {
background-color: #4CAF50;
color: white;
padding: 8px;
border: none;
border-radius: 4px;
}
QPushButton:disabled { background-color: #cccccc; }
QTextEdit { border: 1px solid #ddd; border-radius: 4px; }
""")
# Titel
title = QLabel("Audio Transcriber")
title.setFont(QFont("Helvetica", 16, QFont.Bold))
title.setAlignment(Qt.AlignCenter)
layout.addWidget(title)
# Status
self.status_label = QLabel("Bereit")
self.status_label.setAlignment(Qt.AlignCenter)
layout.addWidget(self.status_label)
# Buttons
self.record_btn = QPushButton("Aufnahme starten")
self.record_btn.clicked.connect(self.start_recording)
layout.addWidget(self.record_btn)
self.stop_btn = QPushButton("Aufnahme stoppen")
self.stop_btn.clicked.connect(self.stop_recording)
self.stop_btn.setEnabled(False)
layout.addWidget(self.stop_btn)
# Textfeld
self.result_text = QTextEdit()
self.result_text.setReadOnly(True)
layout.addWidget(self.result_text)
# Copy Button
self.copy_btn = QPushButton("In Zwischenablage kopieren")
self.copy_btn.clicked.connect(self.copy_to_clipboard)
self.copy_btn.setEnabled(False)
layout.addWidget(self.copy_btn)
def start_recording(self):
self.worker = AudioWorker(self.fs)
self.worker.recording = True
self.worker.finished.connect(self.on_recording_finished)
self.worker.status_update.connect(self.update_status)
self.worker.start()
self.record_btn.setEnabled(False)
self.stop_btn.setEnabled(True)
self.status_label.setText("Aufnahme läuft...")
def stop_recording(self):
if self.worker:
self.worker.stop_recording()
def on_recording_finished(self, result):
self.result_text.setText(result)
self.status_label.setText("Abgeschlossen")
self.record_btn.setEnabled(True)
self.stop_btn.setEnabled(False)
self.copy_btn.setEnabled(True)
# Text vorlesen
tts = pyttsx3.init()
tts.say(result)
tts.runAndWait()
def update_status(self, status):
self.status_label.setText(status)
def copy_to_clipboard(self):
inhalt = self.result_text.toPlainText()
pyperclip.copy(inhalt)
pyautogui.hotkey('ctrl', 'v')
self.status_label.setText("Text kopiert und eingefügt!")
def main():
app = QApplication(sys.argv)
window = AudioTranscriberWindow()
window.show()
sys.exit(app.exec_())
if __name__ == "__main__":
main()Speichert diesen Code in einer Datei, z. B. audio_transcriber.py, und führt ihn mit python audio_transcriber.py aus.
Wie funktioniert die Anwendung?
- GUI: Die Benutzeroberfläche ist mit PyQt5 gebaut und bietet Buttons zum Starten und Stoppen der Aufnahme sowie ein Textfeld für die Ergebnisse.
- Aufnahme: Die Klasse AudioWorker nutzt sounddevice, um Audio mit einer Abtastrate von 44.1 kHz aufzunehmen und in einer WAV-Datei zu speichern.
- Transkription: Whisper wird über die Kommandozeile aufgerufen, um die Aufnahme zu transkribieren und optional zu übersetzen.
- Ergebnisse: Der transkribierte Text wird angezeigt, vorgelesen (via pyttsx3) und kann in die Zwischenablage kopiert werden.
Tipps und Erweiterungen
- Modell anpassen: Im Code verwende ich das medium-Modell von Whisper. Ihr könnt small für schnellere Ergebnisse oder large für bessere Genauigkeit testen.
- Sprache: Whisper erkennt die Sprache automatisch, aber für eine feste Sprache könnt ihr –language de (für Deutsch) hinzufügen.
- Fehlerbehandlung: Ich habe eine einfache Fehlerbehandlung eingebaut, die ihr z. B. für fehlende Mikrofone oder Netzwerkprobleme erweitern könnt.
Nützliche Links
- OpenAI Whisper auf GitHub – Offizielle Dokumentation und Quellcode.
- PyQt5 Dokumentation – Mehr über die GUI-Bibliothek.
- Sounddevice Dokumentation – Details zur Audioaufnahme.
Schreibe einen Kommentar