1. Einleitung

Sprach-zu-Text (Speech-to-Text, STT) wandelt gesprochene Sprache in geschriebenen Text um und findet immer breiter Anwendung: von virtuellen Assistenten über automatische Untertitelung bis hin zu Smart-Home-Steuerung. In diesem Beitrag zeigen wir, wie Sie auf einem Raspberry Pi 5 mithilfe von OpenAIs Whisper eine lokale STT-Lösung aufsetzen und ausführen.

2. Was ist OpenAI Whisper?

OpenAI Whisper ist ein freies, neuronales Modell für automatische Spracherkennung (ASR). Es bietet:

• Mehrsprachige Erkennung
• Hohe Genauigkeit selbst bei Hintergrundgeräuschen
• Offline-Verarbeitung – ideal für Edge-Geräte wie Raspberry Pi

3. Voraussetzungen

Bevor Sie starten, benötigen Sie:

• Raspberry Pi 5 mit aktuell installiertem Raspberry Pi OS
• USB-Mikrofon, das am Pi als ALSA-Gerät erkannt wird
• Python 3 (>= 3.7) und pip
• Internetverbindung zum Installieren der Python-Pakete

4. Installation

System-Abhängigkeiten installieren

sudo apt update
sudo apt install -y python3-pip libsndfile1

Python-Pakete installieren

pip3 install git+https://github.com/openai/whisper.git \
sounddevice soundfile numpy

5. Python-Skript Beispiel

Speichern Sie den folgenden Code beispielsweise als whisper_record.py:

#!/usr/bin/env python3
import argparse
import tempfile

import numpy as np
import sounddevice as sd
import soundfile as sf
import whisper


def list_devices():
    """Print a list of available input devices with their indices."""
    print("Available audio input devices:")
    for idx, dev in enumerate(sd.query_devices()):
        if dev['max_input_channels'] > 0:
            print(f"  [{idx}] {dev['name']} (default_samplerate: {dev['default_samplerate']:.0f})")


def record_audio(duration: float, device: int, samplerate: float) -> np.ndarray:
    """
    Records `duration` seconds of audio from the given device at its native samplerate.
    Returns a mono float32 NumPy array.
    """
    sd.default.device = device
    sd.default.samplerate = samplerate
    sd.default.channels = 1
    print(f"Recording {duration:.1f}s from device #{device} @ {samplerate:.0f} Hz...")
    audio = sd.rec(int(duration * samplerate), dtype='float32')
    sd.wait()
    return np.squeeze(audio)


def save_wav(audio: np.ndarray, samplerate: int, path: str):
    """Save the NumPy array to a WAV file."""
    sf.write(path, audio, samplerate)
    print(f"Audio written to {path}")


def transcribe(model_name: str, audio_path: str, language: str = None) -> str:
    """Load Whisper model and transcribe the WAV on disk."""
    print(f"Loading Whisper model '{model_name}'...")
    model = whisper.load_model(model_name)
    print("Transcribing...")
    opts = {}
    if language:
        opts["language"] = language
        opts["task"] = "transcribe"
    result = model.transcribe(audio_path, **opts)
    return result["text"].strip()


def main():
    parser = argparse.ArgumentParser(
        description="Record from a USB mic and transcribe locally with Whisper"
    )
    parser.add_argument("--list-devices", action="store_true",
                        help="List audio input devices and exit")
    parser.add_argument("--device", type=int, default=None,
                        help="ALSA device index (see --list-devices)")
    parser.add_argument("--duration", type=float, default=5.0,
                        help="Record length in seconds")
    parser.add_argument("--model", default="tiny",
                        help="Whisper model (tiny, base, small, medium, large)")
    parser.add_argument("--lang", default=None,
                        help="Force language code (e.g. 'en'), skips detection")
    args = parser.parse_args()

    if args.list_devices:
        list_devices()
        return

    if args.device is None:
        device = sd.default.device[0]
        print(f"No device specified; using default input device #{device}")
    else:
        device = args.device

    info = sd.query_devices(device, 'input')
    samplerate = info['default_samplerate']

    audio = record_audio(duration=args.duration, device=device, samplerate=samplerate)

    with tempfile.NamedTemporaryFile(suffix=".wav", delete=False) as tmp:
        save_wav(audio, samplerate=int(samplerate), path=tmp.name)
        text = transcribe(model_name=args.model, audio_path=tmp.name, language=args.lang)

    print("\nTranscription Result:")
    print("="*40)
    print(text)
    print("="*40)


if __name__ == "__main__":
    main()

6. Nutzung

So verwenden Sie das Skript:

1 - Mache das Skript ausführbar:

sudo chmod +x whisper_record.py

2 - Geräte auflisten:

./whisper_record.py --list-devices

3 - Aufnahme und Transkription starten (z. B. Gerät 2, 8 Sekunden, Modell small, Sprache en):

./whisper_record.py --device 2 --duration 8 --model small --lang en

4 - Das Skript zeigt nach Abschluss die erkannte Sprache als Text an.

7. Mehr KI Projekte

Mit diesem Setup verwandeln Sie Ihren Raspberry Pi 5 in eine lokale Speech-to-Text-Station – ganz ohne Cloud-Verbindung. OpenAI Whisper liefert zuverlässige Ergebnisse auch bei einfachen USB-Mikrofonen und lässt sich dank Python und pip unkompliziert installieren und nutzen.

Wir von pi3g, dem Team hinter buyzero.de, stehen Ihnen als erfahrene Partner im AI-Consulting zur Seite. Ob Konzeptentwicklung, Prototyping oder die Produktion skalierbarer KI-Hardwarelösungen – wir unterstützen Sie bei jedem Schritt Ihrer KI-Projekte. Dank unserer langjährigen Expertise in den Bereichen Künstliche Intelligenz und spezialisierter Embedded-Hardware realisieren wir maßgeschneiderte Lösungen, die genau auf Ihre Anforderungen zugeschnitten sind.

Jetzt Consulting vereinbaren!