Einen KI-Assistenten mit lokalen Modellen bauen · Teil 11 von 13 der Serie
Teil 11: Stimme raus: Text zu Sprache
Gib dem Assistenten eine Stimme. Lass die Sprachausgabe Piper auf deinem eigenen Rechner laufen, pack ihren Ton von Hand in eine WAV-Datei und spiel die Antwort im Browser Satz für Satz ab, damit die ersten Worte schnell kommen.
Einen KI-Assistenten mit lokalen Modellen bauenTeil 11 von 13
Auf dieser Seite
Quest-Ziele
- Eine Piper-Stimme auf dem eigenen Rechner laufen lassen
- Verstehen, was in einer WAV-Datei steckt
- Ton im Browser abspielen
- Eine Antwort Satz für Satz sprechen
- Wissen, warum die Antworten von Anfang an kurz gehalten wurden
Pixel hört dich und antwortet schriftlich. In diesem Teil bekommt es eine Stimme. Der Weg ist der aus dem letzten Teil, nur rückwärts: Text geht an deinen Rechner, ein Modell macht Samples daraus, und die Seite spielt sie ab.
Eine Stimme
Piper ist eine freie, schnelle Sprachausgabe mit Stimmen für Dutzende Sprachen. Sie läuft mit der Bibliothek, die du im letzten Teil installiert hast. Lade eine Stimme herunter, etwa 115 MB:
$ cd models$ curl -LO https://github.com/k2-fsa/sherpa-onnx/releases/download/tts-models/vits-piper-de_DE-thorsten-high.tar.bz2$ tar xjf vits-piper-de_DE-thorsten-high.tar.bz2$ rm vits-piper-de_DE-thorsten-high.tar.bz2$ cd ..
Eine Stimme ist ein Ordner: das Modell, eine Liste der Laute, die es kennt, und Daten, um geschriebene Wörter in diese Laute zu verwandeln. Trag ihren Namen in src/language.ts ein, denn eine Stimme spricht eine Sprache:
/** Die Piper-Stimme, ein Ordner in models/. */
export const VOICE = 'vits-piper-de_DE-thorsten-high';Weitere Stimmen findest du auf der Release-Seite; alles, was mit vits-piper- anfängt, funktioniert hier. Jetzt die Sprachausgabe, src/voice/tts.ts („text to speech“, Text zu Sprache):
import { readdirSync } from 'node:fs';
import { VOICE } from '../language.ts';
import { MODELS, sherpa } from './sherpa.ts';
const folder = `${MODELS}/${VOICE}`;
/** The voice, loaded once when the server starts. */
const voice = await sherpa.OfflineTts.createAsync({
model: {
vits: {
model: `${folder}/${readdirSync(folder).find((file) => file.endsWith('.onnx'))}`,
tokens: `${folder}/tokens.txt`,
dataDir: `${folder}/espeak-ng-data`,
},
numThreads: 4,
provider: 'cpu',
debug: 0,
},
maxNumSentences: 1,
});
let queue: Promise<unknown> = Promise.resolve();
/** Speaks the text and returns the sound as a WAV file. */
export function speak(text: string): Promise<Buffer> {
const result = queue.then(async () => {
const audio = await voice.generateAsync({ text, sid: 0, speed: 1 });
return wav(audio.samples, audio.sampleRate);
});
queue = result.catch(() => {});
return result;
}
/** Packs samples into a WAV file: a header of 44 bytes, then every sample as a 16-bit number. */
function wav(samples: Float32Array, sampleRate: number): Buffer {
const file = Buffer.alloc(44 + samples.length * 2);
file.write('RIFF', 0);
file.writeUInt32LE(36 + samples.length * 2, 4);
file.write('WAVEfmt ', 8);
file.writeUInt32LE(16, 16); // length of the format part
file.writeUInt16LE(1, 20); // 1 = plain samples (PCM)
file.writeUInt16LE(1, 22); // one channel
file.writeUInt32LE(sampleRate, 24);
file.writeUInt32LE(sampleRate * 2, 28); // bytes a second
file.writeUInt16LE(2, 32); // bytes per sample
file.writeUInt16LE(16, 34); // bits per sample
file.write('data', 36);
file.writeUInt32LE(samples.length * 2, 40);
samples.forEach((sample, i) => {
file.writeInt16LE(Math.round(Math.max(-1, Math.min(1, sample)) * 32767), 44 + i * 2);
});
return file;
}speak gibt der Stimme einen Text und bekommt Samples zurück, als Kommazahlen von -1 bis 1, zusammen mit der Abtastrate der Stimme. Wie beim Zuhören wird immer nur ein Text auf einmal gesprochen.
Eine WAV-Datei von Hand
Ein Browser kann nackte Samples nicht abspielen: Er will die Abtastrate und das Format wissen. Die einfachste Datei, die das sagt, ist eine WAV-Datei, und wav schreibt eine von Hand. Das ist ein guter Moment, um zu sehen, dass so ein Dateiformat kein Geheimnis ist: 44 Bytes, die sagen „das ist Ton, ein Kanal, so viele Samples pro Sekunde, je 16 Bit“, und danach die Samples. Jede Zeile der Funktion schreibt eine dieser Angaben an ihren festen Platz.
Der Server bekommt eine Adresse dafür. In src/server.ts:
import { speak } from './voice/tts.ts';
// ...
if (request.method === 'POST' && pathname === '/api/speak') {
response.writeHead(200, { 'content-type': 'audio/wav' });
return response.end(await speak((await body(request)).toString()));
}Abspielen
Leg public/speak.js an:
let context;
/** The end of what is being said now, so the next sentence waits its turn. */
let line = Promise.resolve();
function play(sound) {
return new Promise((done) => {
const source = context.createBufferSource();
source.buffer = sound;
source.connect(context.destination);
source.onended = done;
source.start();
});
}
/** Speaks the text, sentence by sentence. The promise ends when the last one has been played. */
export function speak(text) {
// a browser lets a page make sound only after a click or a key press, which there has been by now
context ??= new AudioContext();
context.resume();
const sentences = text.match(/[^.!?]+[.!?]+(?=\s|$)|[^.!?]+$/g) ?? [];
// ask for every sentence at once, play them in order: the first one starts while the rest is still being made
const sounds = sentences.map(async (sentence) => {
const response = await fetch('/api/speak', { method: 'POST', body: sentence.trim() });
return context.decodeAudioData(await response.arrayBuffer());
});
for (const sound of sounds) {
line = line.then(async () => play(await sound)).catch((error) => console.error(error));
}
return line;
}Die Funktion schickt nicht die ganze Antwort auf einmal zum Sprechen. Sie zerlegt sie in Sätze und fragt alle im selben Moment an. Der Server erzeugt sie nacheinander, und die Seite spielt jeden ab, sobald er da ist und an der Reihe. Die Wirkung: Du hörst den ersten Satz, während der zweite noch entsteht. Auf dem echten Assistenten ist der erste Satz einer Antwort nach etwa 0,4 Sekunden fertig, egal wie lang die Antwort ist.
line ist ein kleiner Trick, den du in dieser Serie jetzt dreimal gesehen hast: ein Promise, das für „alles, was vorher angefangen wurde“ steht. Was als Nächstes kommt, wartet darauf und nimmt dann seinen Platz ein. Mehr braucht eine Warteschlange nicht.
Ergänze einen Schalter in public/index.html, unter dem Formular:
<p class="switches">
<label><input type="checkbox" id="voice" /> Antworten vorlesen</label>
</p>Und lass in public/app.js die Funktion answered sprechen: Füg oben den Import und die Konstante ein und ersetz die Funktion.
import { speak } from './speak.js';
// ...
const voice = document.querySelector('#voice');
// ...
/** Shows Pixel's answer and speaks it, if that is switched on. Ends when it has been said. */
async function answered(answer) {
show('pixel', answer.speech, answer.tier ? `${answer.tier}, ${answer.ms} ms` : '');
if (voice.checked) await speak(answer.speech);
}Starte den Server neu, lade die Seite neu, setz den Haken bei „Antworten vorlesen“ und sag oder tipp etwas. Pixel antwortet laut. Stell einen Timer: Wenn er klingelt, sagt Pixel das von selbst, denn auch Ansagen laufen über answered.
Du kannst jetzt einen Knopf halten, nach dem Wetter fragen und die Antwort hören. Nur der Knopf ist noch im Weg. Im nächsten Teil nimmst du die Hand davon: Pixel hört die ganze Zeit zu und reagiert, wenn es seinen Namen hört.
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.