24 KiB

Raw Permalink Blame History

Tekst naar spraak - Wio Terminal

In dit deel van de les ga je tekst omzetten naar spraak om gesproken feedback te geven.

Tekst naar spraak

De spraakservices SDK die je in de vorige les hebt gebruikt om spraak naar tekst om te zetten, kan ook worden gebruikt om tekst terug om te zetten naar spraak.

Een lijst met stemmen ophalen

Bij het aanvragen van spraak moet je de stem opgeven die gebruikt moet worden, omdat spraak kan worden gegenereerd met verschillende stemmen. Elke taal ondersteunt een reeks verschillende stemmen, en je kunt de lijst met ondersteunde stemmen voor elke taal ophalen via de spraakservices SDK. Hier komen de beperkingen van microcontrollers om de hoek kijken - de oproep om de lijst met stemmen op te halen die door de tekst-naar-spraakservices wordt ondersteund, is een JSON-document van meer dan 77KB groot, veel te groot om door de Wio Terminal te worden verwerkt. Op het moment van schrijven bevat de volledige lijst 215 stemmen, elk gedefinieerd door een JSON-document zoals het volgende:

{
    "Name": "Microsoft Server Speech Text to Speech Voice (en-US, AriaNeural)",
    "DisplayName": "Aria",
    "LocalName": "Aria",
    "ShortName": "en-US-AriaNeural",
    "Gender": "Female",
    "Locale": "en-US",
    "StyleList": [
        "chat",
        "customerservice",
        "narration-professional",
        "newscast-casual",
        "newscast-formal",
        "cheerful",
        "empathetic"
    ],
    "SampleRateHertz": "24000",
    "VoiceType": "Neural",
    "Status": "GA"
}

Deze JSON is voor de Aria-stem, die meerdere stemstijlen heeft. Het enige dat nodig is bij het omzetten van tekst naar spraak is de shortname, en-US-AriaNeural.

In plaats van deze hele lijst te downloaden en te decoderen op je microcontroller, moet je wat extra serverloze code schrijven om de lijst met stemmen voor de taal die je gebruikt op te halen en deze aanroepen vanaf je Wio Terminal. Je code kan dan een geschikte stem uit de lijst kiezen, zoals de eerste die wordt gevonden.

Taak - maak een serverloze functie om een lijst met stemmen op te halen

Open je smart-timer-trigger-project in VS Code en open de terminal, zorg ervoor dat de virtuele omgeving is geactiveerd. Zo niet, sluit en herstart de terminal.
Open het bestand local.settings.json en voeg instellingen toe voor de spraak-API-sleutel en locatie:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Vervang <key> door de API-sleutel voor je spraakservicebron. Vervang <location> door de locatie die je hebt gebruikt bij het aanmaken van de spraakservicebron.
Voeg een nieuwe HTTP-trigger toe aan deze app genaamd get-voices met behulp van het volgende commando in de VS Code-terminal in de hoofdmap van het functies-app-project:
```
func new --name get-voices --template "HTTP trigger"
```
Dit maakt een HTTP-trigger genaamd get-voices.

Vervang de inhoud van het bestand __init__.py in de map get-voices door het volgende:

import json
import os
import requests

import azure.functions as func

def main(req: func.HttpRequest) -> func.HttpResponse:
    location = os.environ['SPEECH_LOCATION']
    speech_key = os.environ['SPEECH_KEY']

    req_body = req.get_json()
    language = req_body['language']

    url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/voices/list'

    headers = {
        'Ocp-Apim-Subscription-Key': speech_key
    }

    response = requests.get(url, headers=headers)
    voices_json = json.loads(response.text)

    voices = filter(lambda x: x['Locale'].lower() == language.lower(), voices_json)
    voices = map(lambda x: x['ShortName'], voices)

    return func.HttpResponse(json.dumps(list(voices)), status_code=200)

Deze code maakt een HTTP-verzoek naar het eindpunt om de stemmen op te halen. Deze lijst met stemmen is een groot JSON-blok met stemmen voor alle talen, dus de stemmen voor de taal die in de request body wordt doorgegeven, worden eruit gefilterd, waarna de shortname wordt geëxtraheerd en als een JSON-lijst wordt geretourneerd. De shortname is de waarde die nodig is om tekst naar spraak om te zetten, dus alleen deze waarde wordt geretourneerd.

💁 Je kunt het filter indien nodig aanpassen om alleen de stemmen te selecteren die je wilt.

Dit verkleint de grootte van de gegevens van 77KB (op het moment van schrijven) naar een veel kleiner JSON-document. Voor bijvoorbeeld Amerikaanse stemmen is dit 408 bytes.

Voer je functies-app lokaal uit. Je kunt dit vervolgens aanroepen met een tool zoals curl, op dezelfde manier als je de text-to-timer HTTP-trigger hebt getest. Zorg ervoor dat je je taal doorgeeft als een JSON-body:
```
{
    "language":"<language>"
}
```
Vervang <language> door je taal, zoals en-GB of zh-CN.

💁 Je kunt deze code vinden in de map code-spoken-response/functions.

Taak - haal de stem op vanaf je Wio Terminal

Open het smart-timer-project in VS Code als het nog niet open is.
Open het headerbestand config.h en voeg de URL toe voor je functies-app:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Vervang <URL> door de URL voor de get-voices HTTP-trigger van je functies-app. Dit zal hetzelfde zijn als de waarde voor TEXT_TO_TIMER_FUNCTION_URL, behalve dat de functienaam get-voices is in plaats van text-to-timer.
Maak een nieuw bestand in de map src genaamd text_to_speech.h. Dit wordt gebruikt om een klasse te definiëren die tekst naar spraak converteert.

Voeg de volgende include-directieven toe aan de bovenkant van het nieuwe bestand text_to_speech.h:

#pragma once

#include <Arduino.h>
#include <ArduinoJson.h>
#include <HTTPClient.h>
#include <Seeed_FS.h>
#include <SD/Seeed_SD.h>
#include <WiFiClient.h>
#include <WiFiClientSecure.h>

#include "config.h"
#include "speech_to_text.h"

Voeg hieronder de volgende code toe om de TextToSpeech-klasse te declareren, samen met een instantie die in de rest van de applicatie kan worden gebruikt:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Om je functies-app aan te roepen, moet je een WiFi-client declareren. Voeg het volgende toe aan het private-gedeelte van de klasse:
```
WiFiClient _client;
```
Voeg in het private-gedeelte een veld toe voor de geselecteerde stem:
```
String _voice;
```
Voeg aan het public-gedeelte een init-functie toe die de eerste stem ophaalt:
```
void init()
{
}
```
Om de stemmen op te halen, moet een JSON-document naar de functies-app worden verzonden met de taal. Voeg de volgende code toe aan de init-functie om dit JSON-document te maken:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

String body;
serializeJson(doc, body);
```
Maak vervolgens een HTTPClient en gebruik deze om de functies-app aan te roepen om de stemmen op te halen, waarbij je het JSON-document post:
```
HTTPClient httpClient;
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);

int httpResponseCode = httpClient.POST(body);
```

Voeg hieronder code toe om de response code te controleren, en als deze 200 (succes) is, de lijst met stemmen te extraheren en de eerste uit de lijst op te halen:

if (httpResponseCode == 200)
{
    String result = httpClient.getString();
    Serial.println(result);

    DynamicJsonDocument doc(1024);
    deserializeJson(doc, result.c_str());

    JsonArray obj = doc.as<JsonArray>();
    _voice = obj[0].as<String>();

    Serial.print("Using voice ");
    Serial.println(_voice);
}
else
{
    Serial.print("Failed to get voices - error ");
    Serial.println(httpResponseCode);
}

Sluit na dit alles de HTTP-clientverbinding:
```
httpClient.end();
```
Open het bestand main.cpp en voeg de volgende include-directive toe aan de bovenkant om dit nieuwe headerbestand op te nemen:
```
#include "text_to_speech.h"
```
Voeg in de setup-functie, onder de aanroep van speechToText.init();, het volgende toe om de TextToSpeech-klasse te initialiseren:
```
textToSpeech.init();
```

Bouw deze code, upload deze naar je Wio Terminal en test het via de seriële monitor. Zorg ervoor dat je functies-app actief is.

Je ziet de lijst met beschikbare stemmen die door de functies-app wordt geretourneerd, samen met de geselecteerde stem.

--- Available filters and text transformations: colorize, debug, default, direct, hexlify, log2file, nocontrol, printable, send_on_enter, time
--- More details at http://bit.ly/pio-monitor-filters
--- Miniterm on /dev/cu.usbmodem1101  9600,8,N,1 ---
--- Quit: Ctrl+C | Menu: Ctrl+T | Help: Ctrl+T followed by Ctrl+H ---
Connecting to WiFi..
Connected!
Got access token.
["en-US-JennyNeural", "en-US-JennyMultilingualNeural", "en-US-GuyNeural", "en-US-AriaNeural", "en-US-AmberNeural", "en-US-AnaNeural", "en-US-AshleyNeural", "en-US-BrandonNeural", "en-US-ChristopherNeural", "en-US-CoraNeural", "en-US-ElizabethNeural", "en-US-EricNeural", "en-US-JacobNeural", "en-US-MichelleNeural", "en-US-MonicaNeural", "en-US-AriaRUS", "en-US-BenjaminRUS", "en-US-GuyRUS", "en-US-ZiraRUS"]
Using voice en-US-JennyNeural
Ready.

Tekst omzetten naar spraak

Zodra je een stem hebt om te gebruiken, kan deze worden gebruikt om tekst om te zetten naar spraak. Dezelfde geheugenbeperkingen met stemmen gelden ook bij het omzetten van spraak naar tekst, dus je moet de spraak opslaan op een SD-kaart om deze af te spelen via de ReSpeaker.

💁 In eerdere lessen in dit project heb je flashgeheugen gebruikt om spraak op te slaan die is vastgelegd met de microfoon. Deze les gebruikt een SD-kaart omdat het eenvoudiger is om audio ervan af te spelen met behulp van de Seeed-audiobibliotheken.

Er is ook een andere beperking om rekening mee te houden: de beschikbare audiogegevens van de spraakservice en de formaten die de Wio Terminal ondersteunt. In tegenstelling tot volledige computers kunnen audiobibliotheken voor microcontrollers zeer beperkt zijn in de audioformaten die ze ondersteunen. Bijvoorbeeld, de Seeed Arduino Audio-bibliotheek die geluid kan afspelen via de ReSpeaker ondersteunt alleen audio met een samplefrequentie van 44,1 kHz. De Azure-spraakservices kunnen audio leveren in een aantal formaten, maar geen van deze gebruikt deze samplefrequentie; ze bieden alleen 8 kHz, 16 kHz, 24 kHz en 48 kHz. Dit betekent dat de audio opnieuw moet worden gesampled naar 44,1 kHz, iets wat meer middelen vereist dan de Wio Terminal heeft, vooral qua geheugen.

Wanneer je gegevens zoals deze moet manipuleren, is het vaak beter om serverloze code te gebruiken, vooral als de gegevens via een weboproep worden verkregen. De Wio Terminal kan een serverloze functie aanroepen, de tekst doorgeven om te converteren, en de serverloze functie kan zowel de spraakservice aanroepen om tekst naar spraak om te zetten als de audio opnieuw samplen naar de vereiste samplefrequentie. Vervolgens kan het de audio teruggeven in de vorm die de Wio Terminal nodig heeft om op de SD-kaart op te slaan en af te spelen via de ReSpeaker.

Taak - maak een serverloze functie om tekst naar spraak te converteren

Open je smart-timer-trigger-project in VS Code en open de terminal, zorg ervoor dat de virtuele omgeving is geactiveerd. Zo niet, sluit en herstart de terminal.
Voeg een nieuwe HTTP-trigger toe aan deze app genaamd text-to-speech met behulp van het volgende commando in de VS Code-terminal in de hoofdmap van het functies-app-project:
```
func new --name text-to-speech --template "HTTP trigger"
```
Dit maakt een HTTP-trigger genaamd text-to-speech.
Het librosa Pip-pakket heeft functies om audio opnieuw te samplen, dus voeg dit toe aan het bestand requirements.txt:
```
librosa
```
Zodra dit is toegevoegd, installeer je de Pip-pakketten met het volgende commando in de VS Code-terminal:
```
pip install -r requirements.txt
```
⚠️ Als je Linux gebruikt, inclusief Raspberry Pi OS, moet je mogelijk libsndfile installeren met het volgende commando:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Om tekst naar spraak te converteren, kun je de spraak-API-sleutel niet direct gebruiken. In plaats daarvan moet je een toegangstoken aanvragen, waarbij je de API-sleutel gebruikt om de toegangstokenaanvraag te verifiëren. Open het bestand __init__.py uit de map text-to-speech en vervang alle code erin door het volgende:

import io
import os
import requests

import librosa
import soundfile as sf
import azure.functions as func

location = os.environ['SPEECH_LOCATION']
speech_key = os.environ['SPEECH_KEY']

def get_access_token():
    headers = {
        'Ocp-Apim-Subscription-Key': speech_key
    }

    token_endpoint = f'https://{location}.api.cognitive.microsoft.com/sts/v1.0/issuetoken'
    response = requests.post(token_endpoint, headers=headers)
    return str(response.text)

Dit definieert constanten voor de locatie en spraaksleutel die worden gelezen uit de instellingen. Vervolgens definieert het de functie get_access_token die een toegangstoken voor de spraakservice ophaalt.

Voeg onder deze code het volgende toe:

playback_format = 'riff-48khz-16bit-mono-pcm'

def main(req: func.HttpRequest) -> func.HttpResponse:
    req_body = req.get_json()
    language = req_body['language']
    voice = req_body['voice']
    text = req_body['text']

    url = f'https://{location}.tts.speech.microsoft.com/cognitiveservices/v1'

    headers = {
        'Authorization': 'Bearer ' + get_access_token(),
        'Content-Type': 'application/ssml+xml',
        'X-Microsoft-OutputFormat': playback_format
    }

    ssml =  f'<speak version=\'1.0\' xml:lang=\'{language}\'>'
    ssml += f'<voice xml:lang=\'{language}\' name=\'{voice}\'>'
    ssml += text
    ssml += '</voice>'
    ssml += '</speak>'

    response = requests.post(url, headers=headers, data=ssml.encode('utf-8'))

    raw_audio, sample_rate = librosa.load(io.BytesIO(response.content), sr=48000)
    resampled = librosa.resample(raw_audio, sample_rate, 44100)

    output_buffer = io.BytesIO()
    sf.write(output_buffer, resampled, 44100, 'PCM_16', format='wav')
    output_buffer.seek(0)

    return func.HttpResponse(output_buffer.read(), status_code=200)

Dit definieert de HTTP-trigger die tekst naar spraak converteert. Het haalt de tekst op om te converteren, de taal en de stem uit de JSON-body die naar het verzoek is verzonden, bouwt wat SSML om de spraak aan te vragen, en roept vervolgens de relevante REST API aan waarbij het toegangstoken wordt gebruikt voor authenticatie. Deze REST API-aanroep retourneert de audio gecodeerd als een 16-bit, 48 kHz mono WAV-bestand, gedefinieerd door de waarde van playback_format, die wordt verzonden naar de REST API-aanroep.

Vervolgens wordt deze audio opnieuw gesampled door librosa van een samplefrequentie van 48 kHz naar een samplefrequentie van 44,1 kHz. Daarna wordt deze audio opgeslagen in een binair buffer dat vervolgens wordt geretourneerd.

Voer je functies-app lokaal uit of implementeer deze in de cloud. Je kunt dit vervolgens aanroepen met een tool zoals curl, op dezelfde manier als je de text-to-timer HTTP-trigger hebt getest. Zorg ervoor dat je de taal, stem en tekst doorgeeft als de JSON-body:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Vervang <language> door je taal, zoals en-GB of zh-CN. Vervang <voice> door de stem die je wilt gebruiken. Vervang <text> door de tekst die je wilt omzetten naar spraak. Je kunt de uitvoer opslaan in een bestand en afspelen met elke audioplayer die WAV-bestanden kan afspelen.

Bijvoorbeeld, om "Hello" om te zetten naar spraak in het Amerikaans-Engels met de Jenny Neural-stem, met de functies-app lokaal draaiend, kun je het volgende curl-commando gebruiken:
```
curl -X GET 'http://localhost:7071/api/text-to-speech' \
     -H 'Content-Type: application/json' \
     -o hello.wav \
     -d '{
       "language":"en-US",
       "voice": "en-US-JennyNeural",
       "text": "Hello"
     }'
```
Dit slaat de audio op als hello.wav in de huidige map.