23 KiB

Raw Permalink Blame History Unescape Escape

Tekst til tale - Wio Terminal

I denne delen av leksjonen skal du konvertere tekst til tale for å gi muntlig tilbakemelding.

Tekst til tale

SDK-en for tale-tjenester som du brukte i forrige leksjon for å konvertere tale til tekst, kan også brukes til å konvertere tekst tilbake til tale.

Hent en liste over stemmer

Når du ber om tale, må du spesifisere hvilken stemme som skal brukes, siden tale kan genereres med en rekke forskjellige stemmer. Hvert språk støtter et utvalg av ulike stemmer, og du kan få en liste over støttede stemmer for hvert språk fra tale-tjenestenes SDK. Her kommer begrensningene til mikrokontrollere inn i bildet – kallet for å hente listen over stemmer som støttes av tekst-til-tale-tjenestene er et JSON-dokument på over 77KB, altfor stort til å behandles av Wio Terminal. På tidspunktet for skriving inneholder hele listen 215 stemmer, hver definert av et JSON-dokument som dette:

{
    "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"
}

Dette JSON-dokumentet er for stemmen Aria, som har flere stemmestiler. Alt som trengs for å konvertere tekst til tale er kortnavnet, en-US-AriaNeural.

I stedet for å laste ned og dekode hele denne listen på mikrokontrolleren, må du skrive litt mer serverløs kode for å hente listen over stemmer for språket du bruker, og kalle denne fra Wio Terminal. Koden din kan deretter velge en passende stemme fra listen, for eksempel den første den finner.

Oppgave - opprett en serverløs funksjon for å hente en liste over stemmer

Åpne prosjektet ditt smart-timer-trigger i VS Code, og åpne terminalen, og sørg for at det virtuelle miljøet er aktivert. Hvis ikke, avslutt og opprett terminalen på nytt.
Åpne filen local.settings.json og legg til innstillinger for tale-API-nøkkelen og plasseringen:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Erstatt <key> med API-nøkkelen for tale-tjenesten din. Erstatt <location> med plasseringen du brukte da du opprettet tale-tjenesten.
Legg til en ny HTTP-trigger i denne appen kalt get-voices ved å bruke følgende kommando fra terminalen i rotmappen til funksjonsapp-prosjektet:
```
func new --name get-voices --template "HTTP trigger"
```
Dette vil opprette en HTTP-trigger kalt get-voices.

Erstatt innholdet i filen __init__.py i mappen get-voices med følgende:

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)

Denne koden gjør et HTTP-kall til endepunktet for å hente stemmene. Listen over stemmer er en stor JSON-blokk med stemmer for alle språk, så stemmene for språket som sendes i forespørselens kropp blir filtrert ut, og deretter blir kortnavnet hentet ut og returnert som en JSON-liste. Kortnavnet er verdien som trengs for å konvertere tekst til tale, så bare denne verdien returneres.

💁 Du kan endre filteret etter behov for å velge bare de stemmene du ønsker.

Dette reduserer datastørrelsen fra 77KB (på tidspunktet for skriving) til et mye mindre JSON-dokument. For eksempel, for amerikanske stemmer er dette 408 byte.

Kjør funksjonsappen din lokalt. Du kan deretter kalle denne ved å bruke et verktøy som curl på samme måte som du testet HTTP-triggeren text-to-timer. Sørg for å sende språket som en JSON-kropp:
```
{
    "language":"<language>"
}
```
Erstatt <language> med språket ditt, for eksempel en-GB eller zh-CN.

💁 Du finner denne koden i mappen code-spoken-response/functions.

Oppgave - hent stemmen fra Wio Terminal

Åpne prosjektet smart-timer i VS Code hvis det ikke allerede er åpent.
Åpne header-filen config.h og legg til URL-en for funksjonsappen din:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Erstatt <URL> med URL-en for HTTP-triggeren get-voices i funksjonsappen din. Dette vil være det samme som verdien for TEXT_TO_TIMER_FUNCTION_URL, bortsett fra at funksjonsnavnet er get-voices i stedet for text-to-timer.
Opprett en ny fil i mappen src kalt text_to_speech.h. Denne vil bli brukt til å definere en klasse for å konvertere fra tekst til tale.

Legg til følgende include-direktiver øverst i den nye filen 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"

Legg til følgende kode under dette for å erklære klassen TextToSpeech, sammen med en instans som kan brukes i resten av applikasjonen:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
For å kalle funksjonsappen din, må du erklære en WiFi-klient. Legg til følgende i den private delen av klassen:
```
WiFiClient _client;
```
I den private delen, legg til et felt for den valgte stemmen:
```
String _voice;
```
I den offentlige delen, legg til en init-funksjon som vil hente den første stemmen:
```
void init()
{
}
```
For å hente stemmene, må et JSON-dokument sendes til funksjonsappen med språket. Legg til følgende kode i init-funksjonen for å opprette dette JSON-dokumentet:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

String body;
serializeJson(doc, body);
```

Opprett deretter en HTTPClient, og bruk den til å kalle funksjonsappen for å hente stemmene, ved å sende JSON-dokumentet:

HTTPClient httpClient;
httpClient.begin(_client, GET_VOICES_FUNCTION_URL);

int httpResponseCode = httpClient.POST(body);

Under dette, legg til kode for å sjekke svarskoden, og hvis den er 200 (suksess), hent listen over stemmer og velg den første fra listen:

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);
}

Etter dette, avslutt HTTP-klienttilkoblingen:
```
httpClient.end();
```
Åpne filen main.cpp, og legg til følgende include-direktiv øverst for å inkludere denne nye header-filen:
```
#include "text_to_speech.h"
```
I setup-funksjonen, under kallet til speechToText.init();, legg til følgende for å initialisere klassen TextToSpeech:
```
textToSpeech.init();
```

Bygg denne koden, last den opp til Wio Terminal og test den gjennom seriemonitoren. Sørg for at funksjonsappen din kjører.

Du vil se listen over tilgjengelige stemmer returnert fra funksjonsappen, sammen med den valgte stemmen.

--- 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.

Konverter tekst til tale

Når du har en stemme å bruke, kan den brukes til å konvertere tekst til tale. De samme minnebegrensningene med stemmer gjelder også når du konverterer tekst til tale, så du må skrive talen til et SD-kort for å kunne spille den av via ReSpeaker.

💁 I tidligere leksjoner i dette prosjektet brukte du flashminne for å lagre tale fanget fra mikrofonen. Denne leksjonen bruker et SD-kort, da det er enklere å spille av lyd fra det ved hjelp av Seeed-lydbibliotekene.

Det er også en annen begrensning å vurdere, nemlig tilgjengelige lyddata fra tale-tjenesten og formatene som Wio Terminal støtter. I motsetning til fullverdige datamaskiner, kan lydbiblioteker for mikrokontrollere være svært begrenset i lydformatene de støtter. For eksempel støtter Seeed Arduino Audio-biblioteket som kan spille lyd via ReSpeaker kun lyd med en samplingsfrekvens på 44,1 kHz. Azure tale-tjenester kan levere lyd i flere formater, men ingen av dem bruker denne samplingsfrekvensen; de tilbyr kun 8 kHz, 16 kHz, 24 kHz og 48 kHz. Dette betyr at lyden må re-samples til 44,1 kHz, noe som krever mer ressurser enn det Wio Terminal har, spesielt minne.

Når det er behov for å manipulere data som dette, er det ofte bedre å bruke serverløs kode, spesielt hvis dataene hentes via et webkall. Wio Terminal kan kalle en serverløs funksjon, sende inn teksten som skal konverteres, og den serverløse funksjonen kan både kalle tale-tjenesten for å konvertere tekst til tale, samt re-sample lyden til den nødvendige samplingsfrekvensen. Den kan deretter returnere lyden i det formatet Wio Terminal trenger for å lagres på SD-kortet og spilles av via ReSpeaker.

Oppgave - opprett en serverløs funksjon for å konvertere tekst til tale

Åpne prosjektet ditt smart-timer-trigger i VS Code, og åpne terminalen, og sørg for at det virtuelle miljøet er aktivert. Hvis ikke, avslutt og opprett terminalen på nytt.
Legg til en ny HTTP-trigger i denne appen kalt text-to-speech ved å bruke følgende kommando fra terminalen i rotmappen til funksjonsapp-prosjektet:
```
func new --name text-to-speech --template "HTTP trigger"
```
Dette vil opprette en HTTP-trigger kalt text-to-speech.
Pip-pakken librosa har funksjoner for å re-sample lyd, så legg denne til i filen requirements.txt:
```
librosa
```
Når dette er lagt til, installer Pip-pakkene ved å bruke følgende kommando fra VS Code-terminalen:
```
pip install -r requirements.txt
```
⚠️ Hvis du bruker Linux, inkludert Raspberry Pi OS, må du kanskje installere libsndfile med følgende kommando:
```
sudo apt update
sudo apt install libsndfile1-dev
```

For å konvertere tekst til tale kan du ikke bruke tale-API-nøkkelen direkte, i stedet må du be om en tilgangstoken, ved å bruke API-nøkkelen for å autentisere forespørselen om tilgangstoken. Åpne filen __init__.py fra mappen text-to-speech og erstatt all koden i den med følgende:

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)

Dette definerer konstanter for plasseringen og tale-nøkkelen som vil bli lest fra innstillingene. Det definerer deretter funksjonen get_access_token som vil hente en tilgangstoken for tale-tjenesten.

Under denne koden, legg til følgende:

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)

Dette definerer HTTP-triggeren som konverterer tekst til tale. Den henter teksten som skal konverteres, språket og stemmen fra JSON-kroppen sendt til forespørselen, bygger litt SSML for å be om talen, og kaller deretter den relevante REST-API-en ved å autentisere med tilgangstokenet. Dette REST-API-kallet returnerer lyden kodet som en 16-bit, 48 kHz mono WAV-fil, definert av verdien av playback_format, som sendes til REST-API-kallet.

Dette blir deretter re-samplet av librosa fra en samplingsfrekvens på 48 kHz til en samplingsfrekvens på 44,1 kHz, og denne lyden lagres deretter i en binær buffer som returneres.

Kjør funksjonsappen din lokalt, eller distribuer den til skyen. Du kan deretter kalle denne ved å bruke et verktøy som curl på samme måte som du testet HTTP-triggeren text-to-timer. Sørg for å sende språket, stemmen og teksten som JSON-kropp:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Erstatt <language> med språket ditt, for eksempel en-GB eller zh-CN. Erstatt <voice> med stemmen du vil bruke. Erstatt <text> med teksten du vil konvertere til tale. Du kan lagre utdataene til en fil og spille den av med en hvilken som helst lydspiller som kan spille WAV-filer.

For eksempel, for å konvertere "Hello" til tale ved bruk av amerikansk engelsk med stemmen Jenny Neural, med funksjonsappen kjørende lokalt, kan du bruke følgende curl-kommando:
```
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"
     }'
```
Dette vil lagre lyden til hello.wav i den gjeldende katalogen.