# 12.06.2025 Speech-to-text
## Vosk

Für die Anwendung mit Vosk wird zunächst ein geeignetes Modell benötigt.
Auf der folgenden Seite kann aus einer Vielzahl von Sprachen und Modellgrößen gewählt werden: https://alphacephei.com/vosk/models
Je größer das Modell, desto umfangreicher ist in der Regel auch der Wortschatz und die Qualität der Texterkennung.

Im Allgemeinen handelt es sich bei Vosk um ein eher leichtgewichtiges Spracherkennungstool.
Es stellt geringe Anforderungen an die Hardware und ermöglicht durch die teilweise kleinen Modelle auch Einsätze auf mobilen oder Embedded-Systemen.

### Anwendung

Mithilfe von `model = Model("vosk-model-de-0.21")` kann das gewählte Modell geladen werden. Dieser Vorgang kann etwas Zeit in Anspruch nehmen.

Neben dem Modell selbst müssen weitere Parameter wie z. B. die Abtastrate definiert werden: `samplerate=16000`.

Diese kann anschließend verwendet werden, um mit `rec = KaldiRecognizer(model, samplerate)` einen `KaldiRecognizer` zu erzeugen.

Um Sprache aufzunehmen, benötigt man eine Queue sowie eine Callback-Funktion, die auf Fehler prüft und die Audiodaten in die Queue legt:

```

q = queue.Queue()
def callback(indata, frames, time, status):
    if status:
        print(status, file=sys.stderr)
    q.put(bytes(indata))
```

Diese Parameter können nun verwendet werden, um eine Rohdaten-Audioaufnahme zu starten.
Eine Blockgröße (blocksize) von 8000 entspricht etwa 0,5 Sekunden und ermöglicht damit eine Echtzeitverarbeitung:

```
with sd.RawInputStream(samplerate=samplerate, blocksize=8000, dtype='int16',
                       channels=1, callback=callback):
    print("Sprich etwas (Strg+C zum Beenden) ...")
    try:
        while True:
            data = q.get()
            if rec.AcceptWaveform(data):
                result = json.loads(rec.Result())
                print("Erkannt:", result.get("text"))
            else:
                # Zwischenstand (optional)
                # partial = json.loads(rec.PartialResult())
                pass
    except KeyboardInterrupt:
        print("\nBeendet.")
```

Solange das Programm nicht manuell vom Nutzer unterbrochen wird, wartet es auf neue Audiodaten in der Queue.
Wird ein vollständiger Text erkannt, kann das Ergebnis weiterverarbeitet werden.

https://www.pageon.ai/blog/speech-to-text-ai


## Whisper

### Installation

Zunächst muss per 

- pip install -U openai-whisper

die Python Library installiert werden.  


Anschließend wird noch ffmpeg benötigt (herunterladen entweder von der offiziellen Seite https://ffmpeg.org/download.html)
oder einfach direkt per Paketmanager `sudo apt install ffmpeg` installieren.


### Anwendung

Whisper unterstützt 6 Übersetzungsmodelle. Je größer, umso besser ist die Erkennungsqualität. Dafür werden aber auch mehr Ressourcen benötigt, bzw. dauert es länger.



#### Importieren und Laden des Modells:
```
import whisper

model = whisper.load_model("medium")  # z.B. small, base, medium, large
```
Lädt das vordefinierte Whisper-Modell. Dies dauert beim Ersten mal etwas länger.


#### Parameter für Audioaufnahme
```
samplerate = 16000
duration = 30 # Sekunden
```
Für Whisper wird eine Aufnahme benötigt. Im Gegensatz zu Vosk kann Whisper die Aufnahme nicht in Echtzeit verarbeiten. Stattdessen wird hier die Aufnahme zuerst beendet und dann erst die gesamte Aufnahme bearbeitet.
Whisper wartet also 30 Sekunden ab (Hier kann ins Mikrofon gesprochen werden). Danach wird die Audio in Text umgewandelt.



```
print("Sprich etwas (Strg+C zum Beenden)...")

try:
    while True:

except KeyboardInterrupt:
    print("\nBeendet.")
```

Solange Strg+C nicht das Programm unterbricht, wiederholt sich folgender Vorgang: 30 Sekunden aufnehmen, bearbeiten, Ausgeben von Text.

#### Aufnahme
```
    print("Aufnahme...")
    audio = sd.rec(int(samplerate * duration), samplerate=samplerate, channels=1, dtype='float32')
    sd.wait()  # Aufnahme beenden
```
Mit sounddevice.rec wird 30 Sekunden lang aufgenommen.

#### Vorverarbeitung des Audios und Spracherkennung
```
    print("=> Bearbeit...") 
    audio = np.squeeze(audio)  # (samples, 1) -> (samples,)
        
    # Whisper erwartet np.float32 mit Werten in [-1,1], das passt
        
    result = model.transcribe(audio, language="de")  # Sprache Deutsch, optional
```
Das Modell transkripiert den gesprochenen Text. Die Sprache ist explizit als deutsch angegeben. Das Ergebnis wird in result gespeichert und dann ausgegeben:
        print("Erkannt:", result["text"])

https://github.com/openai/whisper