Einen KI-Assistenten mit lokalen Modellen bauen · Teil 10 von 13 der Serie
Teil 10: Stimme rein: Sprache zu Text
Gib dem Assistenten Ohren. Nimm deine Stimme im Browser auf, solange du einen Knopf hältst, schick sie an deinen eigenen Rechner und lass Whisper, eine Spracherkennung, die lokal läuft, Text daraus machen.
Einen KI-Assistenten mit lokalen Modellen bauenTeil 10 von 13
Auf dieser Seite
Quest-Ziele
- Verstehen, wie aus Ton Zahlen werden
- Die Spracherkennung Whisper auf dem eigenen Rechner laufen lassen
- Im Browser vom Mikrofon aufnehmen
- Eine Aufnahme an den Server schicken und Text zurückbekommen
- Aufräumen, was eine Spracherkennung erfindet
Am Schreibtisch ist es in Ordnung, einem Assistenten zu schreiben. In der Küche, mit Teig an den Händen, willst du sprechen. In diesem Teil und den beiden nächsten lernt Pixel zuzuhören, zu sprechen und auf seinen Namen zu warten. Die Seite im Browser ist Mikrofon und Lautsprecher; das Zuhören und das Sprechen selbst passieren auf deinem Rechner, mit Modellen, die dort laufen, genau wie das Sprachmodell.
In diesem Teil geht es um Spracherkennung, also „Sprache zu Text“: Ton geht rein, ein Satz kommt raus, und dieser Satz nimmt denselben Weg wie einer, den du getippt hast.
Ton als Zahlen
Ein Mikrofon misst den Luftdruck viele tausend Mal pro Sekunde. Jede Messung ist eine Zahl, ein Sample (auf Deutsch: Abtastwert), und eine Aufnahme ist nichts als eine lange Liste davon. Zwei Dinge beschreiben so eine Liste:
die Abtastrate: wie viele Samples es pro Sekunde gibt. Musik verwendet 44.100 oder 48.000. Spracherkennungen wollen 16.000, und das reicht für eine Stimme völlig.
das Format eines Samples: entweder eine ganze Zahl von -32.768 bis 32.767 (16 Bit, kompakt, gut zum Verschicken) oder eine Kommazahl von -1 bis 1 (damit rechnet Audiosoftware).
Eine Sekunde Sprache sind also 16.000 Zahlen oder 32.000 Bytes. Mehr „Audio“ wirst du nicht herumschicken.
Whisper auf deinem Rechner
Whisper ist ein Modell für Spracherkennung, das OpenAI frei veröffentlicht hat. Es versteht rund hundert Sprachen und kommt mit Akzenten und Hintergrundgeräuschen zurecht. Um es laufen zu lassen, verwendest du sherpa-onnx, eine freie Bibliothek für Modelle, die hören und sprechen. Sie läuft unter Windows, macOS und Linux und braucht keine Grafikkarte. Installier sie:
$ npm install sherpa-onnx-node@1.13.8Lade dann das Modell herunter, etwa 640 MB, in einen Ordner models:
$ mkdir models$ cd models$ curl -LO https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/sherpa-onnx-whisper-small.tar.bz2$ tar xjf sherpa-onnx-whisper-small.tar.bz2$ rm sherpa-onnx-whisper-small.tar.bz2$ cd ..
Das ist Whisper „small“. Es braucht etwa 1 GB Arbeitsspeicher, passt also auf einem Rechner mit 8 GB neben das Sprachmodell. Es gibt größere Whisper-Modelle, die genauer hören, und wenn du Arbeitsspeicher übrig hast, ist sherpa-onnx-whisper-turbo von derselben Stelle ein guter nächster Schritt: Auf dem echten Assistenten machte es deutlich weniger Fehler, bei etwa doppelt so viel Arbeitsspeicher.
Die Bibliothek ist ein Paket ohne Typen, also beschreibst du die Teile, die Pixel verwendet, einmal selbst, in src/voice/sherpa.ts:
/**
* sherpa-onnx-node is a CommonJS package with native code and without types, so it is loaded
* with require, and the few parts Pixel uses are described here.
*/
import { createRequire } from 'node:module';
interface Recognizer {
createStream(): { acceptWaveform(audio: { samples: Float32Array; sampleRate: number }): void };
decodeAsync(stream: object): Promise<{ text: string }>;
}
interface Tts {
generateAsync(request: { text: string; sid: number; speed: number }): Promise<{ samples: Float32Array; sampleRate: number }>;
}
export interface Vad {
acceptWaveform(samples: Float32Array): void;
isEmpty(): boolean;
front(enableExternalBuffer: boolean): { start: number; samples: Float32Array };
pop(): void;
}
interface Sherpa {
OfflineRecognizer: { createAsync(config: object): Promise<Recognizer> };
OfflineTts: { createAsync(config: object): Promise<Tts> };
Vad: new (config: object, bufferSizeInSeconds: number) => Vad;
}
export const sherpa = createRequire(import.meta.url)('sherpa-onnx-node') as Sherpa;
/** Where the downloaded models are. */
export const MODELS = 'models';Die Interfaces fürs Sprechen (Tts) und fürs Finden von Sprache (Vad) sind für die nächsten beiden Teile. Jetzt die Spracherkennung, src/voice/stt.ts („speech to text“, Sprache zu Text):
import { LOCALE } from '../language.ts';
import { MODELS, sherpa } from './sherpa.ts';
import { clean } from './text.ts';
const folder = `${MODELS}/sherpa-onnx-whisper-small`;
/** Whisper, loaded once when the server starts. */
const recognizer = await sherpa.OfflineRecognizer.createAsync({
featConfig: { sampleRate: 16000, featureDim: 80 },
modelConfig: {
whisper: {
encoder: `${folder}/small-encoder.int8.onnx`,
decoder: `${folder}/small-decoder.int8.onnx`,
// without a language Whisper guesses, and short commands come out in the wrong one
language: LOCALE.slice(0, 2),
task: 'transcribe',
tailPaddings: 1000,
},
tokens: `${folder}/small-tokens.txt`,
numThreads: 4,
provider: 'cpu',
debug: 0,
},
decodingMethod: 'greedy_search',
});
/** One recording at a time: the recognizer already uses several processor cores. */
let queue: Promise<unknown> = Promise.resolve();
/** Turns a recording (16 000 samples a second, one channel) into text. */
export function transcribe(samples: Float32Array): Promise<string> {
const result = queue.then(async () => {
// under a third of a second there is no word in it
if (samples.length < 16000 * 0.3) return '';
const stream = recognizer.createStream();
stream.acceptWaveform({ samples, sampleRate: 16000 });
const { text } = await recognizer.decodeAsync(stream);
return clean(text);
});
queue = result.catch(() => {});
return result;
}Das Modell zu laden dauert ein, zwei Sekunden und passiert einmal, wenn der Server startet. transcribe nimmt Samples und gibt Text zurück. Drei Details darin hat der echte Assistent auf die harte Tour gelernt:
Die Sprache steht fest. Eine Spracherkennung, die die Sprache rät, hat bei einem Befehl aus drei Wörtern wenig Anhaltspunkte. Eine frühere Spracherkennung des echten Assistenten machte aus kurzen deutschen Befehlen englischen Unsinn. Sagst du Whisper die Sprache, fällt diese ganze Fehlerklasse weg.
Eine Aufnahme nach der anderen. Die Spracherkennung nutzt schon für eine Aufnahme vier Prozessorkerne. Zwei gleichzeitig würden sich nur gegenseitig im Weg stehen, also stellen sie sich an.
Nichts unter einer Drittelsekunde. Darin steckt kein Wort, und was Whisper aus Nicht-Wörtern macht, ist das nächste Thema.
Was niemand gesagt hat
Whisper hat aus einer riesigen Menge von Videos mit Untertiteln gelernt. Gib ihm Stille oder Rauschen, und es schreibt, was es am leisen Ende eines Videos am häufigsten gesehen hat: „Vielen Dank fürs Zuschauen.“ Das ist kein Fehler, den du beheben kannst. So ist das Modell, und jedes Programm, das Whisper verwendet, muss hinter ihm aufräumen. Leg src/voice/text.ts an:
import { NOT_SAID } from '../language.ts';
/**
* Tidies what Whisper wrote. On silence and noise it likes to invent sentences it saw at the
* end of many videos, and now and then it repeats itself.
*/
export function clean(text: string): string {
const sentences = text
.replace(/\[[^\]]*\]|\([^)]*\)|[♪♫]+/g, ' ') // [Music], (applause), ♪
.split(/(?<=[.!?])\s+/)
.map((sentence) => sentence.trim())
.filter((sentence) => sentence && !NOT_SAID.test(sentence.toLowerCase().replace(/[.!?,]/g, '').trim()));
// "What time is it? What time is it?" is said once
const once = sentences.filter((sentence, i) => sentence !== sentences[i - 1]);
return once.join(' ');
}Und die Liste der Sätze, die niemand gesagt hat, in src/language.ts:
/** Sätze, die niemand gesagt hat: Whisper erfindet sie, wenn es Stille oder Rauschen hört. */
export const NOT_SAID =
/^(vielen dank|danke|danke schön|vielen dank fürs zuschauen|vielen dank fürs zuhören|bis zum nächsten mal|untertitel .*|tschüss|so|ja)$/;Die Liste wird wachsen. Immer wenn Pixel auf etwas reagiert, das du nicht gesagt hast, schau nach, was die Spracherkennung geschrieben hat, und ergänze es.
Der Server nimmt Aufnahmen an
Ergänze in src/server.ts den Import und eine weitere Adresse, über der für /api/events:
import { transcribe } from './voice/stt.ts';
// ...
if (request.method === 'POST' && pathname === '/api/hear') {
// the recording arrives as 16-bit samples; the recognizer wants numbers from -1 to 1
const bytes = await body(request);
const samples = new Int16Array(bytes.buffer, bytes.byteOffset, Math.floor(bytes.byteLength / 2));
return json(response, { text: await transcribe(Float32Array.from(samples, (sample) => sample / 32768)) });
}Die Seite schickt die Aufnahme als rohe 16-Bit-Samples, sonst nichts: kein Dateiformat, kein Header. Der Server liest die Bytes als Zahlen, macht für die Spracherkennung Kommazahlen von -1 bis 1 daraus und antwortet mit dem Text.
Das Mikrofon im Browser
Drei kleine Dateien übernehmen die Aufnahme. Die erste läuft im Audio-Thread des Browsers und macht den Ton klein genug zum Verschicken. Leg public/capture.js an:
/**
* Runs on the browser's audio thread. The microphone delivers 44 100 or 48 000 samples a
* second as numbers from -1 to 1; speech recognition wants 16 000 a second. So this takes
* the average of every three or so samples and posts them in packets of 20 milliseconds,
* as 16-bit numbers.
*/
const RATE = 16000;
const PACKET = 320;
class Capture extends AudioWorkletProcessor {
step = sampleRate / RATE; // `sampleRate` is the rate of the audio context
position = 0;
sum = 0;
count = 0;
packet = new Int16Array(PACKET);
filled = 0;
process(inputs) {
const channel = inputs[0]?.[0];
if (!channel) return true;
for (const sample of channel) {
this.sum += sample;
this.count += 1;
this.position += 1;
if (this.position < this.step) continue;
this.position -= this.step;
const average = this.sum / this.count;
this.sum = 0;
this.count = 0;
this.packet[this.filled] = Math.max(-32768, Math.min(32767, Math.round(average * 32767)));
this.filled += 1;
if (this.filled === PACKET) {
this.port.postMessage(this.packet.buffer, [this.packet.buffer]);
this.packet = new Int16Array(PACKET);
this.filled = 0;
}
}
return true;
}
}
registerProcessor('capture', Capture);Der Browser reicht diesem Code den Ton des Mikrofons in kleinen Portionen, mit seiner eigenen Rate von 44.100 oder 48.000 Samples pro Sekunde. Die Schleife fasst je etwa drei Samples zu einem Durchschnitt zusammen, was die Rate auf 16.000 senkt, und sammelt die Ergebnisse in Paketen zu 320: je 20 Millisekunden. Ein volles Paket geht an die Seite.
Die zweite Datei öffnet das Mikrofon, public/mic.js:
/** Everyone who wants the microphone's sound, packet by packet. */
const listeners = new Set();
let opening;
async function open() {
if (!navigator.mediaDevices) throw new Error('The microphone needs https or http://localhost.');
const stream = await navigator.mediaDevices.getUserMedia({
audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, channelCount: 1 },
});
const context = new AudioContext();
await context.audioWorklet.addModule('capture.js');
const capture = new AudioWorkletNode(context, 'capture');
capture.port.onmessage = (event) => {
for (const listener of listeners) listener(event.data);
};
// the browser only runs what leads to the speakers, so lead there, silently
const silence = context.createGain();
silence.gain.value = 0;
context.createMediaStreamSource(stream).connect(capture).connect(silence).connect(context.destination);
}
/**
* Calls `listener` with every packet of sound: 20 milliseconds as an ArrayBuffer of 16-bit
* samples. The first call asks for the microphone. Returns a function that stops it.
*/
export async function onSound(listener) {
// if opening fails, the next call may try again
opening ??= open().catch((error) => {
opening = undefined;
throw error;
});
await opening;
listeners.add(listener);
return () => listeners.delete(listener);
}getUserMedia fragt nach dem Mikrofon, und der Browser fragt dich. Die drei Optionen schalten ein, was auch Telefonate nutzen: Echounterdrückung, Rauschunterdrückung und automatische Lautstärke. Das Mikrofon wird einmal geöffnet, bei der ersten Verwendung, und bleibt dann offen; wer seinen Ton haben will, meldet einen Listener an.
Die dritte Datei ist der Knopf, public/talk.js:
import { onSound } from './mic.js';
/** Records while the button is held, has the server turn it into text and hands that on. */
export function setupTalk(button, onText) {
let packets = [];
let held = false;
let stop;
button.addEventListener('pointerdown', async () => {
held = true;
packets = [];
button.classList.add('active');
try {
const off = await onSound((packet) => packets.push(packet));
// the very first press waits for the permission; the button may be up again by then
if (held) stop = off;
else off();
} catch (error) {
// no microphone, or no permission to use it
button.classList.remove('active');
alert(error.message);
}
});
button.addEventListener('pointerup', async () => {
held = false;
button.classList.remove('active');
stop?.();
stop = undefined;
if (packets.length === 0) return;
const response = await fetch('/api/hear', { method: 'POST', body: new Blob(packets) });
const { text } = await response.json();
if (text) onText(text);
});
}Solange der Knopf gedrückt ist, werden die Pakete gesammelt. Wird er losgelassen, gehen sie als eine Aufnahme an /api/hear, und der Text, der zurückkommt, wird weitergegeben. Füg den Knopf in das Formular in public/index.html ein:
<form id="form">
<input id="text" placeholder="Sag etwas zu Pixel" autocomplete="off" autofocus />
<button>Senden</button>
<button type="button" id="talk">Halten und sprechen</button>
</form>Und verbinde ihn in public/app.js:
import { setupTalk } from './talk.js';
// ... and at the end of the file:
setupTalk(document.querySelector('#talk'), send);Der Knopf gibt den Text an send, dieselbe Funktion, die das Textfeld verwendet. Von da an sind ein gesprochener und ein getippter Satz dasselbe.
Probier es aus
$ npm run servePixel is at http://localhost:3210
Lade die Seite neu, halt den Knopf, sag „Küche an“, lass los. Beim allerersten Drücken fragt der Browser nach dem Mikrofon, drück also noch einmal, nachdem du es erlaubt hast. Dein Satz erscheint im Gespräch, als hättest du ihn getippt, und die Lampe geht an.
Pixel hört dich. Im nächsten Teil antwortet es laut.
Kommentare
Die Kommentare sind GitHub Discussions: Zum Schreiben mit GitHub anmelden.
Die Kommentare kommen über giscus von GitHub. Beim Laden gehen deine IP-Adresse an giscus.app und GitHub.