Einen KI-Assistenten mit lokalen Modellen bauen · Teil 12 von 13 der Serie
Teil 12: Ein Aktivierungswort
Nimm die Hand vom Knopf. Die Seite schickt das Mikrofon die ganze Zeit an deinen Rechner, ein kleines Modell findet die Momente, in denen jemand spricht, und der Assistent antwortet auf die Sätze, die mit seinem Namen beginnen.
Einen KI-Assistenten mit lokalen Modellen bauenTeil 12 von 13
Auf dieser Seite
Quest-Ziele
- Ton fortlaufend über einen WebSocket an den Server schicken
- Mit Sprachaktivitätserkennung Sprache in einem Strom von Ton finden
- Den Namen des Assistenten am Satzanfang erkennen
- Eine Nachfrage ohne den Namen erlauben
- Verhindern, dass der Assistent sich selbst zuhört
„Pixel, mach das Licht in der Küche an.“ Kein Knopf, kein Bildschirm. Damit das geht, muss das Mikrofon offen bleiben, und das wirft zwei Fragen auf. Woher weiß Pixel, wann jemand spricht, ohne die Spracherkennung über Stunden von Stille laufen zu lassen? Und woher weiß es, dass ein Satz ihm gilt und nicht der Katze?
Der Plan
Die Seite schickt die Pakete des Mikrofons die ganze Zeit an deinen Rechner.
Ein winziges Modell beobachtet den Strom und schneidet die Abschnitte heraus, in denen gesprochen wird. Das heißt Sprachaktivitätserkennung, auf Englisch „voice activity detection“, kurz VAD.
Jeder Abschnitt geht an Whisper, wie in Teil 10.
Beginnt der Text mit „Pixel“, ist der Rest eine Anfrage. Wenn nicht, wird er weggeworfen.
Kommerzielle Assistenten verwenden ein besonderes kleines Modell, das auf das eine Aktivierungswort hört und auf sonst nichts. Der echte Assistent hinter dieser Serie hat das auch versucht und dann festgestellt, dass es besser funktioniert, den Namen im Transkript zu lesen: In seinen Tests erwischte das besondere Modell 15 bis 24 von 30 Rufen, das Transkript 25 von 30, und keines von beiden sprang bei einem der 45 Sätze an, die nur ähnlich klangen. Außerdem braucht dieser Weg kein zusätzliches Modell und kein Training auf den Namen deines Assistenten.
Was du brauchst
Ein Paket für WebSockets und das VAD-Modell, das nur 2 MB groß ist:
$ npm install ws$ npm install --save-dev @types/ws$ curl -L -o models/silero_vad_v5.onnx https://github.com/k2-fsa/sherpa-onnx/releases/download/asr-models/silero_vad_v5.onnx
Ein WebSocket ist eine Verbindung zwischen einer Seite und einem Server, die offen bleibt und über die beide Seiten senden können, wann sie wollen. Die Server-Sent Events aus Teil 9 gehen nur in eine Richtung und tragen Text; ein Strom von Ton braucht eine richtige Verbindung.
Sprache finden
Leg src/voice/vad.ts an:
import { MODELS, sherpa } from './sherpa.ts';
/** Silero looks at the sound in windows of 512 samples: 32 milliseconds. */
const WINDOW = 512;
/**
* Finds the stretches of speech in a stream of sound. Feed it whatever arrives; it hands
* back every utterance that has ended since, as samples.
*/
export function createVad(): { feed(samples: Float32Array): Float32Array[] } {
const vad = new sherpa.Vad(
{
sileroVad: {
model: `${MODELS}/silero_vad_v5.onnx`,
threshold: 0.5,
minSilenceDuration: 0.6, // this much silence ends an utterance
minSpeechDuration: 0.25,
maxSpeechDuration: 15,
windowSize: WINDOW,
},
sampleRate: 16000,
numThreads: 1,
provider: 'cpu',
debug: 0,
},
60,
);
let waiting = new Float32Array(0);
return {
feed(samples) {
// what did not fill a window last time comes first
const all = new Float32Array(waiting.length + samples.length);
all.set(waiting);
all.set(samples, waiting.length);
const utterances: Float32Array[] = [];
let at = 0;
for (; at + WINDOW <= all.length; at += WINDOW) {
vad.acceptWaveform(all.subarray(at, at + WINDOW));
while (!vad.isEmpty()) {
utterances.push(vad.front(false).samples);
vad.pop();
}
}
waiting = all.slice(at);
return utterances;
},
};
}Silero ist ein Modell, das zu 32 Millisekunden Ton eine einzige Frage beantwortet: Ist das eine Stimme? Es ist so klein, dass es etwa ein Drittel Prozent eines Prozessorkerns braucht und deshalb den ganzen Tag laufen kann. Die Bibliothek darum herum führt Buch: Hat sie eine Stimme gehört und danach 0,6 Sekunden Stille, gibt sie die ganze Äußerung heraus.
Das Modell will seinen Ton in Fenstern von genau 512 Samples, die Seite schickt aber Pakete zu 320. Also hängt feed das, was ankommt, hinter das, was vom letzten Mal übrig war, füttert so viele ganze Fenster, wie da sind, und behält den Rest.
Bin ich gemeint?
Der Name, in src/language.ts:
/**
* Der Anfang eines Satzes, der für Pixel gedacht ist: eine Begrüßung, wenn man mag, dann der
* Name, wie ihn die Spracherkennung schreibt. Lass dir ausgeben, was sie hört, und ergänze
* die Schreibweisen, die du siehst.
*/
export const WAKE = /^(?:(?:hey|hi|hallo|okay|ok)[,!]? +)?(?:pixel|pixels|pixl|piksel|picsel|pixar)(?![\p{L}\p{N}])[,.!?:]* */iu;Das Muster passt auf einen Satzanfang: eine Begrüßung, die auch fehlen darf, dann der Name in jeder Schreibweise, auf die die Spracherkennung kommt. Whisper hat den Namen deines Assistenten nie in dieser Rolle gelesen und schreibt manchmal „Pixels“ oder „Pixar“. Du findest diese Schreibweisen, indem du beobachtest, was es schreibt, und ergänzt sie.
Ergänze src/voice/text.ts um eine Funktion, die das Muster verwendet, und erweitere den Import ganz oben:
import { NOT_SAID, WAKE } from '../language.ts';
// ...
/**
* Whether the sentence is addressed to Pixel. Returns what comes after the name ("" when
* the name is all there is), or null when the sentence does not start with it.
*/
export function afterWake(text: string): string | null {
const match = WAKE.exec(text);
return match ? text.slice(match[0].length).trim() : null;
}Die Funktion hat drei mögliche Ergebnisse, und der Unterschied zählt: die Wörter nach dem Namen, ein leerer Text, wenn nur der Name gesagt wurde, oder null, wenn der Satz gar nicht an Pixel gerichtet war.
Das offene Mikrofon
Leg src/voice/listen.ts an:
import type { Server } from 'node:http';
import { WebSocketServer } from 'ws';
import { handle } from '../assistant.ts';
import { transcribe } from './stt.ts';
import { afterWake } from './text.ts';
import { createVad } from './vad.ts';
/** After an answer, Pixel keeps listening this long without hearing its name again. */
const FOLLOW_UP_MS = 6000;
/**
* The open microphone: the page sends sound all the time, and Pixel answers the sentences
* that start with its name.
*/
export function listen(server: Server): void {
const sockets = new WebSocketServer({ server, path: '/api/listen' });
sockets.on('connection', (socket) => {
const vad = createVad();
let awakeUntil = 0;
let work: Promise<void> = Promise.resolve();
const send = (message: object) => socket.send(JSON.stringify(message));
async function heard(samples: Float32Array, began: number): Promise<void> {
const text = await transcribe(samples);
if (!text) return;
const command = afterWake(text);
// not addressed to Pixel, and not a follow-up to its last answer: none of its business
if (command === null && began > awakeUntil) return;
if (command === '') {
// only the name: the next sentence counts
awakeUntil = Date.now() + FOLLOW_UP_MS;
return send({ wake: true });
}
const said = command ?? text;
send({ heard: said });
send({ answer: await handle(said) });
}
socket.on('message', (data: Buffer, isBinary: boolean) => {
if (!isBinary) {
// the page has finished speaking the answer
if (data.toString() === 'played') awakeUntil = Date.now() + FOLLOW_UP_MS;
return;
}
const samples = new Int16Array(data.buffer, data.byteOffset, Math.floor(data.byteLength / 2));
for (const utterance of vad.feed(Float32Array.from(samples, (sample) => sample / 32768))) {
const began = Date.now() - utterance.length / 16; // 16 samples are a millisecond
// one after the other, in the order they were said
work = work.then(() => heard(utterance, began)).catch((error) => console.error(error));
}
});
});
}Jede Seite, die sich verbindet, bekommt ihre eigene VAD und ihren eigenen Zustand. Der Ton kommt als binäre Nachrichten an; jede wird an die VAD verfüttert, und jede Äußerung, die dabei herauskommt, geht an heard, streng eine nach der anderen.
heard macht aus der Äußerung Text und entscheidet dann:
Nicht an Pixel gerichtet: weggeworfen, und damit ist die Sache erledigt. Nichts wird gespeichert, nichts wird geloggt.
Nur der Name: Pixel wacht auf, und was in den nächsten sechs Sekunden gesagt wird, zählt.
Name und Anfrage: Die Anfrage geht an
handle, dieselbe Funktion wie immer, und die Seite bekommt, was gehört wurde, und die Antwort.
Die sechs Sekunden sind auch für Nachfragen da. Vor jedem Satz eines Gesprächs den Namen sagen zu müssen, ist mühsam. Meldet die Seite, dass sie eine Antwort zu Ende gesprochen hat, öffnet sich ein Fenster von sechs Sekunden, in dem ein Satz auch ohne den Namen zählt: „Pixel, wie wird das Wetter morgen?“, Antwort, „Und am Donnerstag?“. Entscheidend ist, wann der Satz begonnen hat, und deshalb wird began aus der Länge der Äußerung berechnet.
Starte das Zuhören in src/server.ts:
import { listen } from './voice/listen.ts';
// ...
listen(server);
// 127.0.0.1: only this computer can reach the page
server.listen(PORT, '127.0.0.1', () => console.log(`${NAME} is at http://localhost:${PORT}`));Die Seite
Leg public/listen.js an:
import { onSound } from './mic.js';
/**
* The open microphone: while the box is checked, the sound goes to the server all the time,
* and the server says what it heard and what Pixel answers.
*/
export function setupListen(box, show, answered) {
let socket;
let stop;
/** While Pixel speaks, nothing is sent: it should not listen to itself. */
let speaking = false;
box.addEventListener('change', async () => {
if (!box.checked) {
stop?.();
socket?.close();
return;
}
try {
stop = await onSound((packet) => {
if (!speaking && socket?.readyState === WebSocket.OPEN) socket.send(packet);
});
} catch (error) {
// no microphone, or no permission to use it
box.checked = false;
return alert(error.message);
}
socket = new WebSocket(`ws://${location.host}/api/listen`);
socket.onmessage = async (event) => {
const message = JSON.parse(event.data);
if (message.wake) show('pixel', '…');
if (message.heard) show('you', message.heard);
if (message.answer) {
speaking = true;
await answered(message.answer);
speaking = false;
socket.send('played');
}
};
});
}Solange der Haken gesetzt ist, geht jedes Paket vom Mikrofon direkt in den WebSocket. Die Nachrichten, die zurückkommen, werden angezeigt, und eine Antwort wird gesprochen.
Die Variable speaking löst ein Problem, das dir sonst innerhalb einer Minute auffallen würde: Pixels Stimme kommt aus dem Lautsprecher und geht ins Mikrofon. Sagt es „Pixel ist da“, würde es seinen eigenen Namen hören und sich selbst antworten. Solange also eine Antwort abgespielt wird, wird nichts gesendet. Ist sie vorbei, sagt die Seite dem Server Bescheid, und der öffnet das Fenster für eine Nachfrage.
Ergänze den Schalter in public/index.html:
<p class="switches">
<label><input type="checkbox" id="voice" /> Antworten vorlesen</label>
<label><input type="checkbox" id="listen" /> Auf „Pixel“ hören</label>
</p>Und verbinde ihn in public/app.js:
import { setupListen } from './listen.js';
// ... and at the end of the file:
setupListen(document.querySelector('#listen'), show, answered);Starte den Server neu, lade die Seite neu, setz beide Haken und sag: „Pixel, mach das Licht in der Küche an.“ Dann, gleich nach der Antwort: „Und im Flur auch.“ Den ersten Satz beantwortet eine Regel, den zweiten das Modell, das aus dem Verlauf weiß, was „auch“ bedeutet.
Du kannst jetzt durchs Zimmer gehen und mit deinem Assistenten reden. Er schaltet Lampen in einem Wimpernschlag, versteht, was du meinst, merkt sich deine Familie und erzählt dir vom Wetter, alles auf deinem eigenen Rechner. Was er nicht kann, ist, eine echte Frage zu beantworten. Im letzten Teil lernt er, jemanden zu fragen, der es kann.
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.