25 KiB

Raw Permalink Blame History

Text to speech - Wio Terminal

În această parte a lecției, vei transforma textul în vorbire pentru a oferi feedback vocal.

Text to speech

SDK-ul serviciilor de vorbire pe care l-ai folosit în lecția anterioară pentru a transforma vorbirea în text poate fi utilizat și pentru a transforma textul în vorbire.

Obține o listă de voci

Când soliciți vorbire, trebuie să specifici vocea care va fi utilizată, deoarece vorbirea poate fi generată folosind o varietate de voci diferite. Fiecare limbă suportă o gamă de voci, iar lista vocilor disponibile pentru fiecare limbă poate fi obținută din SDK-ul serviciilor de vorbire. Limitările microcontrolerelor intervin aici - apelul pentru a obține lista vocilor suportate de serviciile text-to-speech este un document JSON de peste 77KB, mult prea mare pentru a fi procesat de Wio Terminal. La momentul redactării, lista completă conține 215 voci, fiecare definită printr-un document JSON precum următorul:

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

Acest JSON este pentru vocea Aria, care are mai multe stiluri vocale. Tot ce este necesar pentru a transforma textul în vorbire este numele scurt, en-US-AriaNeural.

În loc să descarci și să decodezi întreaga listă pe microcontroler, va trebui să scrii un cod serverless suplimentar pentru a prelua lista vocilor pentru limba pe care o folosești și să apelezi acest cod de pe Wio Terminal. Codul tău poate apoi să aleagă o voce potrivită din listă, cum ar fi prima pe care o găsește.

Sarcină - creează o funcție serverless pentru a obține o listă de voci

Deschide proiectul smart-timer-trigger în VS Code și deschide terminalul, asigurându-te că mediul virtual este activat. Dacă nu, închide și recreează terminalul.
Deschide fișierul local.settings.json și adaugă setările pentru cheia API a serviciului de vorbire și locație:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Înlocuiește <key> cu cheia API pentru resursa serviciului de vorbire. Înlocuiește <location> cu locația pe care ai utilizat-o când ai creat resursa serviciului de vorbire.
Adaugă un nou trigger HTTP în această aplicație numit get-voices folosind următoarea comandă din terminalul VS Code, în folderul rădăcină al proiectului aplicației de funcții:
```
func new --name get-voices --template "HTTP trigger"
```
Aceasta va crea un trigger HTTP numit get-voices.

Înlocuiește conținutul fișierului __init__.py din folderul get-voices cu următorul cod:

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)

Acest cod face o cerere HTTP către endpoint pentru a obține vocile. Lista vocilor este un bloc mare de JSON cu voci pentru toate limbile, astfel încât vocile pentru limba transmisă în corpul cererii sunt filtrate, iar numele scurt este extras și returnat ca o listă JSON. Numele scurt este valoarea necesară pentru a transforma textul în vorbire, astfel încât doar această valoare este returnată.

💁 Poți modifica filtrul după cum este necesar pentru a selecta doar vocile dorite.

Aceasta reduce dimensiunea datelor de la 77KB (la momentul redactării) la un document JSON mult mai mic. De exemplu, pentru vocile din SUA, acesta are 408 bytes.

Rulează aplicația de funcții local. Poți apoi să o apelezi folosind un instrument precum curl, la fel cum ai testat trigger-ul HTTP text-to-timer. Asigură-te că transmiți limba ca un corp JSON:
```
{
    "language":"<language>"
}
```
Înlocuiește <language> cu limba ta, cum ar fi en-GB sau zh-CN.

💁 Poți găsi acest cod în folderul code-spoken-response/functions.

Sarcină - preia vocea de pe Wio Terminal

Deschide proiectul smart-timer în VS Code, dacă nu este deja deschis.
Deschide fișierul header config.h și adaugă URL-ul pentru aplicația ta de funcții:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Înlocuiește <URL> cu URL-ul pentru trigger-ul HTTP get-voices din aplicația ta de funcții. Acesta va fi același cu valoarea pentru TEXT_TO_TIMER_FUNCTION_URL, cu excepția faptului că numele funcției va fi get-voices în loc de text-to-timer.
Creează un fișier nou în folderul src numit text_to_speech.h. Acesta va fi utilizat pentru a defini o clasă care transformă textul în vorbire.

Adaugă următoarele directive include în partea de sus a noului fișier 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"

Adaugă următorul cod mai jos pentru a declara clasa TextToSpeech, împreună cu o instanță care poate fi utilizată în restul aplicației:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Pentru a apela aplicația de funcții, trebuie să declari un client WiFi. Adaugă următorul cod în secțiunea private a clasei:
```
WiFiClient _client;
```
În secțiunea private, adaugă un câmp pentru vocea selectată:
```
String _voice;
```
În secțiunea public, adaugă o funcție init care va obține prima voce:
```
void init()
{
}
```
Pentru a obține vocile, un document JSON trebuie trimis către aplicația de funcții cu limba. Adaugă următorul cod în funcția init pentru a crea acest document JSON:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

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

Creează un HTTPClient, apoi folosește-l pentru a apela aplicația de funcții pentru a obține vocile, postând documentul JSON:

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

int httpResponseCode = httpClient.POST(body);

Mai jos, adaugă cod pentru a verifica codul de răspuns, iar dacă este 200 (succes), extrage lista de voci, preluând prima din listă:

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

După aceasta, închide conexiunea clientului HTTP:
```
httpClient.end();
```
Deschide fișierul main.cpp și adaugă următoarea directivă include în partea de sus pentru a include acest nou fișier header:
```
#include "text_to_speech.h"
```
În funcția setup, sub apelul către speechToText.init();, adaugă următorul cod pentru a inițializa clasa TextToSpeech:
```
textToSpeech.init();
```

Compilează acest cod, încarcă-l pe Wio Terminal și testează-l prin monitorul serial. Asigură-te că aplicația ta de funcții rulează.

Vei vedea lista vocilor disponibile returnată de aplicația de funcții, împreună cu vocea selectată.

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

Transformă textul în vorbire

Odată ce ai o voce de utilizat, aceasta poate fi folosită pentru a transforma textul în vorbire. Aceleași limitări de memorie cu vocile se aplică și atunci când transformi textul în vorbire, astfel încât va trebui să scrii vorbirea pe un card SD pentru a fi redată prin ReSpeaker.

💁 În lecțiile anterioare ale acestui proiect, ai folosit memoria flash pentru a stoca vorbirea captată de microfon. Această lecție folosește un card SD, deoarece este mai ușor să redai audio de pe acesta folosind bibliotecile audio Seeed.

Există și o altă limitare de luat în considerare: datele audio disponibile de la serviciul de vorbire și formatele pe care Wio Terminal le suportă. Spre deosebire de computerele complete, bibliotecile audio pentru microcontrolere pot fi foarte limitate în formatele audio pe care le suportă. De exemplu, biblioteca Seeed Arduino Audio care poate reda sunet prin ReSpeaker suportă doar audio la o rată de eșantionare de 44.1KHz. Serviciile de vorbire Azure pot furniza audio în mai multe formate, dar niciunul dintre ele nu folosește această rată de eșantionare; ele oferă doar 8KHz, 16KHz, 24KHz și 48KHz. Aceasta înseamnă că audio-ul trebuie re-eșantionat la 44.1KHz, ceva ce ar necesita mai multe resurse decât are Wio Terminal, în special memorie.

Când este nevoie să manipulezi astfel de date, este adesea mai bine să folosești cod serverless, mai ales dacă datele sunt obținute printr-un apel web. Wio Terminal poate apela o funcție serverless, transmițând textul de convertit, iar funcția serverless poate atât să apeleze serviciul de vorbire pentru a transforma textul în vorbire, cât și să re-eșantioneze audio-ul la rata de eșantionare necesară. Apoi poate returna audio-ul în forma de care Wio Terminal are nevoie pentru a fi stocat pe cardul SD și redat prin ReSpeaker.

Sarcină - creează o funcție serverless pentru a transforma textul în vorbire

Deschide proiectul smart-timer-trigger în VS Code și deschide terminalul, asigurându-te că mediul virtual este activat. Dacă nu, închide și recreează terminalul.
Adaugă un nou trigger HTTP în această aplicație numit text-to-speech folosind următoarea comandă din terminalul VS Code, în folderul rădăcină al proiectului aplicației de funcții:
```
func new --name text-to-speech --template "HTTP trigger"
```
Aceasta va crea un trigger HTTP numit text-to-speech.
Pachetul Pip librosa are funcții pentru re-eșantionarea audio-ului, așa că adaugă-l în fișierul requirements.txt:
```
librosa
```
După ce l-ai adăugat, instalează pachetele Pip folosind următoarea comandă din terminalul VS Code:
```
pip install -r requirements.txt
```
⚠️ Dacă folosești Linux, inclusiv Raspberry Pi OS, este posibil să fie nevoie să instalezi libsndfile cu următoarea comandă:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Pentru a transforma textul în vorbire, nu poți folosi direct cheia API a serviciului de vorbire; în schimb, trebuie să soliciți un token de acces, folosind cheia API pentru a autentifica cererea de token de acces. Deschide fișierul __init__.py din folderul text-to-speech și înlocuiește tot codul din el cu următorul:

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)

Acesta definește constante pentru locație și cheia serviciului de vorbire, care vor fi citite din setări. Apoi definește funcția get_access_token care va prelua un token de acces pentru serviciul de vorbire.

Mai jos de acest cod, adaugă următorul:

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)

Acesta definește trigger-ul HTTP care transformă textul în vorbire. Extrage textul de convertit, limba și vocea din corpul JSON transmis cererii, construiește un SSML pentru a solicita vorbirea, apoi apelează API-ul REST relevant, autentificându-se folosind token-ul de acces. Acest apel API REST returnează audio-ul codificat ca fișier WAV mono de 16 biți, 48KHz, definit de valoarea playback_format, care este transmisă apelului API REST.

Acesta este apoi re-eșantionat de librosa de la o rată de eșantionare de 48KHz la o rată de eșantionare de 44.1KHz, apoi acest audio este salvat într-un buffer binar care este apoi returnat.

Rulează aplicația de funcții local sau distribuie-o în cloud. Poți apoi să o apelezi folosind un instrument precum curl, la fel cum ai testat trigger-ul HTTP text-to-timer. Asigură-te că transmiți limba, vocea și textul ca un corp JSON:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Înlocuiește <language> cu limba ta, cum ar fi en-GB sau zh-CN. Înlocuiește <voice> cu vocea pe care vrei să o folosești. Înlocuiește <text> cu textul pe care vrei să-l transformi în vorbire. Poți salva rezultatul într-un fișier și să-l redai cu orice player audio care poate reda fișiere WAV.

De exemplu, pentru a transforma "Hello" în vorbire folosind engleza americană cu vocea Jenny Neural, cu aplicația de funcții rulând local, poți folosi următoarea comandă curl:
```
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"
     }'
```
Aceasta va salva audio-ul în hello.wav în directorul curent.