24 KiB

Raw Permalink Blame History

Text na reč - Wio Terminal

V tejto časti lekcie prevediete text na reč, aby ste poskytli hovorenú spätnú väzbu.

Text na reč

SDK pre služby reči, ktoré ste použili v predchádzajúcej lekcii na prevod reči na text, môžete použiť aj na prevod textu späť na reč.

Získanie zoznamu hlasov

Pri požiadavke na reč musíte zadať hlas, ktorý sa má použiť, pretože reč môže byť generovaná pomocou rôznych hlasov. Každý jazyk podporuje rôzne hlasy a zoznam podporovaných hlasov pre každý jazyk môžete získať zo služby reči SDK. Tu sa prejavujú obmedzenia mikrokontrolérov - volanie na získanie zoznamu hlasov podporovaných službami text na reč je JSON dokument s veľkosťou viac ako 77 KB, čo je príliš veľké na spracovanie Wio Terminalom. V čase písania tento zoznam obsahuje 215 hlasov, pričom každý je definovaný JSON dokumentom, ako je tento:

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

Tento JSON je pre hlas Aria, ktorý má viacero štýlov hlasu. Na prevod textu na reč stačí krátky názov, en-US-AriaNeural.

Namiesto sťahovania a dekódovania celého tohto zoznamu na vašom mikrokontroléri budete musieť napísať ďalší serverless kód na získanie zoznamu hlasov pre jazyk, ktorý používate, a zavolať ho z vášho Wio Terminalu. Váš kód potom môže vybrať vhodný hlas zo zoznamu, napríklad prvý, ktorý nájde.

Úloha - vytvorte serverless funkciu na získanie zoznamu hlasov

Otvorte svoj projekt smart-timer-trigger vo VS Code a otvorte terminál, pričom sa uistite, že virtuálne prostredie je aktivované. Ak nie, ukončite a znova vytvorte terminál.
Otvorte súbor local.settings.json a pridajte nastavenia pre kľúč API služby reči a umiestnenie:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Nahraďte <key> kľúčom API pre váš zdroj služby reči. Nahraďte <location> umiestnením, ktoré ste použili pri vytváraní zdroja služby reči.
Pridajte nový HTTP trigger do tejto aplikácie s názvom get-voices pomocou nasledujúceho príkazu z terminálu VS Code v koreňovom priečinku projektu aplikácie funkcií:
```
func new --name get-voices --template "HTTP trigger"
```
Tým sa vytvorí HTTP trigger s názvom get-voices.

Nahraďte obsah súboru __init__.py v priečinku get-voices nasledujúcim:

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)

Tento kód vykoná HTTP požiadavku na endpoint na získanie hlasov. Tento zoznam hlasov je veľký blok JSON s hlasmi pre všetky jazyky, takže hlasy pre jazyk odoslaný v tele požiadavky sú filtrované, potom sa extrahuje krátky názov a vráti sa ako JSON zoznam. Krátky názov je hodnota potrebná na prevod textu na reč, takže sa vráti iba táto hodnota.

💁 Filter môžete podľa potreby zmeniť, aby ste vybrali iba hlasy, ktoré chcete.

Tým sa veľkosť údajov zníži z 77 KB (v čase písania) na oveľa menší JSON dokument. Napríklad pre americké hlasy je to 408 bajtov.

Spustite svoju funkčnú aplikáciu lokálne. Potom ju môžete zavolať pomocou nástroja ako curl rovnakým spôsobom, ako ste testovali HTTP trigger text-to-timer. Uistite sa, že odosielate svoj jazyk ako JSON telo:
```
{
    "language":"<language>"
}
```
Nahraďte <language> svojím jazykom, napríklad en-GB alebo zh-CN.

💁 Tento kód nájdete v priečinku code-spoken-response/functions.

Úloha - získajte hlas z vášho Wio Terminalu

Otvorte projekt smart-timer vo VS Code, ak ešte nie je otvorený.
Otvorte hlavičkový súbor config.h a pridajte URL pre vašu funkčnú aplikáciu:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Nahraďte <URL> URL adresou pre HTTP trigger get-voices vo vašej funkčnej aplikácii. Táto bude rovnaká ako hodnota pre TEXT_TO_TIMER_FUNCTION_URL, okrem názvu funkcie get-voices namiesto text-to-timer.
Vytvorte nový súbor v priečinku src s názvom text_to_speech.h. Tento súbor sa použije na definovanie triedy na prevod textu na reč.

Pridajte nasledujúce direktívy include na začiatok nového súboru 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"

Pod týmto deklarujte triedu TextToSpeech spolu s inštanciou, ktorá sa môže použiť v zvyšku aplikácie:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Na volanie vašej funkčnej aplikácie musíte deklarovať WiFi klienta. Pridajte nasledujúce do sekcie private triedy:
```
WiFiClient _client;
```
V sekcii private pridajte pole pre vybraný hlas:
```
String _voice;
```
Do sekcie public pridajte funkciu init, ktorá získa prvý hlas:
```
void init()
{
}
```
Na získanie hlasov je potrebné odoslať JSON dokument do funkčnej aplikácie s jazykom. Pridajte nasledujúci kód do funkcie init na vytvorenie tohto JSON dokumentu:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

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

Následne vytvorte HTTPClient a použite ho na volanie funkčnej aplikácie na získanie hlasov, odoslaním JSON dokumentu:

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

int httpResponseCode = httpClient.POST(body);

Pod týmto pridajte kód na kontrolu kódu odpovede a ak je 200 (úspech), extrahujte zoznam hlasov a získajte prvý zo zoznamu:

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

Po tomto ukončite pripojenie HTTP klienta:
```
httpClient.end();
```
Otvorte súbor main.cpp a pridajte nasledujúcu direktívu include na začiatok, aby ste zahrnuli tento nový hlavičkový súbor:
```
#include "text_to_speech.h"
```
Vo funkcii setup, pod volaním speechToText.init();, pridajte nasledujúce na inicializáciu triedy TextToSpeech:
```
textToSpeech.init();
```

Skontrolujte kód, nahrajte ho do vášho Wio Terminalu a otestujte ho cez sériový monitor. Uistite sa, že vaša funkčná aplikácia beží.

Uvidíte zoznam dostupných hlasov vrátených z funkčnej aplikácie spolu s vybraným hlasom.

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

Prevod textu na reč

Keď máte hlas, ktorý chcete použiť, môžete ho použiť na prevod textu na reč. Rovnaké obmedzenia pamäte pre hlasy platia aj pri prevode reči na text, takže reč budete musieť uložiť na SD kartu, aby sa mohla prehrať cez ReSpeaker.

💁 V predchádzajúcich lekciách tohto projektu ste používali flash pamäť na ukladanie reči zachytenej z mikrofónu. Táto lekcia používa SD kartu, pretože je jednoduchšie prehrávať zvuk z nej pomocou knižníc Seeed audio.

Existuje aj ďalšie obmedzenie, ktoré treba zvážiť, a to dostupné zvukové dáta zo služby reči a formáty, ktoré Wio Terminal podporuje. Na rozdiel od plnohodnotných počítačov môžu byť zvukové knižnice pre mikrokontroléry veľmi obmedzené v podporovaných zvukových formátoch. Napríklad knižnica Seeed Arduino Audio, ktorá dokáže prehrávať zvuk cez ReSpeaker, podporuje iba zvuk so vzorkovacou frekvenciou 44,1 kHz. Služby Azure reči môžu poskytovať zvuk v niekoľkých formátoch, ale žiadny z nich nepoužíva túto vzorkovaciu frekvenciu, poskytujú iba 8 kHz, 16 kHz, 24 kHz a 48 kHz. To znamená, že zvuk musí byť pre-vzorkovaný na 44,1 kHz, čo by vyžadovalo viac zdrojov, než má Wio Terminal, najmä pamäte.

Keď je potrebné manipulovať s údajmi, ako sú tieto, je často lepšie použiť serverless kód, najmä ak sú údaje získavané prostredníctvom webového volania. Wio Terminal môže zavolať serverless funkciu, odovzdať text na prevod a serverless funkcia môže zavolať službu reči na prevod textu na reč, ako aj pre-vzorkovať zvuk na požadovanú vzorkovaciu frekvenciu. Potom môže vrátiť zvuk vo formáte, ktorý Wio Terminal potrebuje, aby sa mohol uložiť na SD kartu a prehrať cez ReSpeaker.

Úloha - vytvorte serverless funkciu na prevod textu na reč

Otvorte svoj projekt smart-timer-trigger vo VS Code a otvorte terminál, pričom sa uistite, že virtuálne prostredie je aktivované. Ak nie, ukončite a znova vytvorte terminál.
Pridajte nový HTTP trigger do tejto aplikácie s názvom text-to-speech pomocou nasledujúceho príkazu z terminálu VS Code v koreňovom priečinku projektu aplikácie funkcií:
```
func new --name text-to-speech --template "HTTP trigger"
```
Tým sa vytvorí HTTP trigger s názvom text-to-speech.
Balík Pip librosa obsahuje funkcie na pre-vzorkovanie zvuku, takže ho pridajte do súboru requirements.txt:
```
librosa
```
Po pridaní nainštalujte balíky Pip pomocou nasledujúceho príkazu z terminálu VS Code:
```
pip install -r requirements.txt
```
⚠️ Ak používate Linux, vrátane Raspberry Pi OS, možno budete musieť nainštalovať libsndfile pomocou nasledujúceho príkazu:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Na prevod textu na reč nemôžete použiť priamo kľúč API služby reči, namiesto toho musíte požiadať o prístupový token, pričom na autentifikáciu požiadavky na prístupový token použijete kľúč API. Otvorte súbor __init__.py z priečinka text-to-speech a nahraďte všetok kód v ňom nasledujúcim:

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)

Tým sa definujú konštanty pre umiestnenie a kľúč služby reči, ktoré sa načítajú z nastavení. Potom sa definuje funkcia get_access_token, ktorá získa prístupový token pre službu reči.

Pod tento kód pridajte nasledujúce:

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)

Tým sa definuje HTTP trigger, ktorý prevádza text na reč. Extrahuje text na prevod, jazyk a hlas z JSON tela odoslaného v požiadavke, vytvorí SSML na požiadavku reči a potom zavolá príslušné REST API, pričom autentifikuje pomocou prístupového tokenu. Toto volanie REST API vráti zvuk kódovaný ako 16-bitový, 48 kHz mono WAV súbor, definovaný hodnotou playback_format, ktorá sa odosiela do volania REST API.

Tento zvuk sa potom pre-vzorkuje pomocou librosa z vzorkovacej frekvencie 48 kHz na vzorkovaciu frekvenciu 44,1 kHz, potom sa tento zvuk uloží do binárneho bufferu, ktorý sa následne vráti.

Spustite svoju funkčnú aplikáciu lokálne alebo ju nasadte do cloudu. Potom ju môžete zavolať pomocou nástroja ako curl rovnakým spôsobom, ako ste testovali HTTP trigger text-to-timer. Uistite sa, že odosielate jazyk, hlas a text ako JSON telo:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Nahraďte <language> svojím jazykom, napríklad en-GB alebo zh-CN. Nahraďte <voice> hlasom, ktorý chcete použiť. Nahraďte <text> textom, ktorý chcete previesť na reč. Výstup môžete uložiť do súboru a prehrať ho pomocou akéhokoľvek prehrávača, ktorý dokáže prehrávať WAV súbory.

Napríklad na prevod "Hello" na reč pomocou americkej angličtiny s hlasom Jenny Neural, s funkčnou aplikáciou bežiacou lokálne, môžete použiť nasledujúci príkaz 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"
     }'
```
Tým sa uloží zvuk do hello.wav v aktuálnom adresári.