23 KiB

Raw Permalink Blame History

Teksti puheeksi - Wio Terminal

Tässä osassa oppituntia muutat tekstin puheeksi tarjotaksesi puhuttua palautetta.

Teksti puheeksi

Puhepalveluiden SDK, jota käytit edellisessä oppitunnissa muuttaaksesi puheen tekstiksi, voidaan käyttää tekstin muuttamiseen takaisin puheeksi.

Hanki lista äänistä

Kun pyydät puhetta, sinun täytyy määrittää käytettävä ääni, sillä puhetta voidaan tuottaa monilla eri äänillä. Jokainen kieli tukee useita eri ääniä, ja puhepalveluiden SDK:sta voit saada listan kunkin kielen tuetuista äänistä. Mikro-ohjainten rajoitukset tulevat tässä esiin - puhepalveluiden tukemien äänien lista on yli 77KB kokoinen JSON-dokumentti, joka on liian suuri käsiteltäväksi Wio Terminalilla. Kirjoitushetkellä täydellinen lista sisältää 215 ääntä, joista jokainen on määritelty JSON-dokumentilla, kuten seuraava:

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

Tämä JSON koskee Aria-ääntä, jolla on useita äänen tyylejä. Tekstin muuttamiseksi puheeksi tarvitaan vain lyhytnimi, en-US-AriaNeural.

Sen sijaan, että lataisit ja dekoodaisit koko listan mikro-ohjaimellasi, sinun täytyy kirjoittaa lisää serverittömiä koodeja hakeaksesi listan käytettävän kielen äänistä ja kutsua tätä Wio Terminalista. Koodisi voi sitten valita sopivan äänen listasta, esimerkiksi ensimmäisen löytämänsä.

Tehtävä - luo serveritön funktio äänilistan hakemiseksi

Avaa smart-timer-trigger-projektisi VS Codessa ja avaa terminaali varmistaen, että virtuaaliympäristö on aktivoitu. Jos ei, lopeta ja luo terminaali uudelleen.
Avaa local.settings.json-tiedosto ja lisää asetukset puhepalvelun API-avaimelle ja sijainnille:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Korvaa <key> puhepalveluresurssisi API-avaimella. Korvaa <location> sijainnilla, jota käytit luodessasi puhepalveluresurssin.
Lisää uusi HTTP-triggeri tähän sovellukseen nimeltä get-voices käyttämällä seuraavaa komentoa VS Code -terminaalissa funktiosovelluksen projektin juurikansiossa:
```
func new --name get-voices --template "HTTP trigger"
```
Tämä luo HTTP-triggerin nimeltä get-voices.

Korvaa get-voices-kansion __init__.py-tiedoston sisältö seuraavalla:

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)

Tämä koodi tekee HTTP-pyynnön endpointiin äänien hakemiseksi. Äänilista on suuri JSON-lohko, joka sisältää kaikkien kielten äänet, joten pyynnön rungossa välitetyn kielen äänet suodatetaan, ja lyhytnimi poimitaan ja palautetaan JSON-listana. Lyhytnimi on arvo, jota tarvitaan tekstin muuttamiseksi puheeksi, joten vain tämä arvo palautetaan.

💁 Voit muuttaa suodatinta tarpeen mukaan valitaksesi vain haluamasi äänet.

Tämä pienentää datan kokoa 77KB:sta (kirjoitushetkellä) paljon pienemmäksi JSON-dokumentiksi. Esimerkiksi Yhdysvaltain äänille tämä on 408 tavua.

Aja funktiosovelluksesi paikallisesti. Voit sitten kutsua tätä työkalulla, kuten curl, samalla tavalla kuin testasit text-to-timer HTTP-triggeriä. Muista välittää kielesi JSON-runkona:
```
{
    "language":"<language>"
}
```
Korvaa <language> kielelläsi, kuten en-GB tai zh-CN.

💁 Löydät tämän koodin code-spoken-response/functions-kansiosta.

Tehtävä - hae ääni Wio Terminalistasi

Avaa smart-timer-projektisi VS Codessa, jos se ei ole jo auki.
Avaa config.h-otsikkotiedosto ja lisää URL funktiosovelluksellesi:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Korvaa <URL> URL:lla get-voices HTTP-triggerille funktiosovelluksessasi. Tämä on sama kuin TEXT_TO_TIMER_FUNCTION_URL-arvo, paitsi että funktiolla on nimi get-voices eikä text-to-timer.
Luo uusi tiedosto src-kansioon nimeltä text_to_speech.h. Tätä käytetään luokan määrittämiseen tekstin muuttamiseksi puheeksi.

Lisää seuraavat include-direktiivit uuden text_to_speech.h-tiedoston alkuun:

#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"

Lisää tämän alle seuraava koodi TextToSpeech-luokan julistamiseksi, sekä instanssi, jota voidaan käyttää sovelluksen muissa osissa:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Kutsua varten funktiosovellusta, sinun täytyy julistaa WiFi-asiakas. Lisää seuraava luokan private-osioon:
```
WiFiClient _client;
```
Lisää private-osioon kenttä valitulle äänelle:
```
String _voice;
```
Lisää public-osioon init-funktio, joka hakee ensimmäisen äänen:
```
void init()
{
}
```
Äänien hakemiseksi JSON-dokumentti täytyy lähettää funktiosovellukseen kielen kanssa. Lisää seuraava koodi init-funktioon luodaksesi tämän JSON-dokumentin:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

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

Luo seuraavaksi HTTPClient ja käytä sitä kutsuaksesi funktiosovellusta äänien hakemiseksi, lähettäen JSON-dokumentin:

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

int httpResponseCode = httpClient.POST(body);

Lisää tämän alle koodi tarkistaaksesi vastauskoodin, ja jos se on 200 (onnistuminen), poimi äänilista ja hae ensimmäinen ääni listasta:

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

Tämän jälkeen lopeta HTTP-asiakasliittymän yhteys:
```
httpClient.end();
```
Avaa main.cpp-tiedosto ja lisää seuraava include-direktiivi alkuun sisällyttääksesi tämän uuden otsikkotiedoston:
```
#include "text_to_speech.h"
```
setup-funktiossa, speechToText.init();-kutsun alapuolelle, lisää seuraava TextToSpeech-luokan alustamiseksi:
```
textToSpeech.init();
```

Rakenna tämä koodi, lataa se Wio Terminaliin ja testaa se sarjamonitorin kautta. Varmista, että funktiosovelluksesi on käynnissä.

Näet funktiosovelluksesta palautetun saatavilla olevien äänien listan sekä valitun äänen.

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

Muunna teksti puheeksi

Kun sinulla on ääni käytettäväksi, sitä voidaan käyttää tekstin muuttamiseen puheeksi. Samat muistirajoitukset, jotka koskevat ääniä, pätevät myös puheen muuttamiseen tekstiksi, joten sinun täytyy kirjoittaa puhe SD-kortille, jotta se voidaan toistaa ReSpeakerin kautta.

💁 Aiemmissa oppitunneissa tässä projektissa käytit flash-muistia mikrofonista tallennetun puheen säilyttämiseen. Tämä oppitunti käyttää SD-korttia, koska sen kautta on helpompi toistaa ääntä Seeed-audiokirjastojen avulla.

On myös toinen rajoitus, joka täytyy ottaa huomioon: saatavilla oleva puhepalvelun tuottama audiodata ja Wio Terminalin tukemat formaatit. Toisin kuin täysimittaiset tietokoneet, mikro-ohjainten audiokirjastot voivat olla hyvin rajallisia tukemiensa audioformaattien suhteen. Esimerkiksi Seeed Arduino Audio -kirjasto, joka voi toistaa ääntä ReSpeakerin kautta, tukee vain ääniformaatteja, joiden näytteenottotaajuus on 44.1KHz. Azure-puhepalvelut voivat tarjota ääntä useissa formaateissa, mutta mikään niistä ei käytä tätä näytteenottotaajuutta; ne tarjoavat vain 8KHz, 16KHz, 24KHz ja 48KHz. Tämä tarkoittaa, että ääni täytyy uudelleennäytteistää 44.1KHz:iin, mikä vaatisi enemmän resursseja kuin Wio Terminalilla on, erityisesti muistia.

Kun dataa täytyy käsitellä tällä tavalla, on usein parempi käyttää serveritöntä koodia, erityisesti jos data on peräisin verkkopyynnöstä. Wio Terminal voi kutsua serveritöntä funktiota, välittää tekstin muutettavaksi, ja serveritön funktio voi sekä kutsua puhepalvelua tekstin muuttamiseksi puheeksi että uudelleennäytteistää äänen tarvittavaan näytteenottotaajuuteen. Se voi sitten palauttaa äänen Wio Terminalin tarvitsemassa muodossa, jotta se voidaan tallentaa SD-kortille ja toistaa ReSpeakerin kautta.

Tehtävä - luo serveritön funktio tekstin muuttamiseksi puheeksi

Avaa smart-timer-trigger-projektisi VS Codessa ja avaa terminaali varmistaen, että virtuaaliympäristö on aktivoitu. Jos ei, lopeta ja luo terminaali uudelleen.
Lisää uusi HTTP-triggeri tähän sovellukseen nimeltä text-to-speech käyttämällä seuraavaa komentoa VS Code -terminaalissa funktiosovelluksen projektin juurikansiossa:
```
func new --name text-to-speech --template "HTTP trigger"
```
Tämä luo HTTP-triggerin nimeltä text-to-speech.
librosa-Pip-paketilla on funktioita äänen uudelleennäytteistämiseen, joten lisää tämä requirements.txt-tiedostoon:
```
librosa
```
Kun tämä on lisätty, asenna Pip-paketit seuraavalla komennolla VS Code -terminaalista:
```
pip install -r requirements.txt
```
⚠️ Jos käytät Linuxia, mukaan lukien Raspberry Pi OS:ää, sinun täytyy ehkä asentaa libsndfile seuraavalla komennolla:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Tekstin muuttamiseksi puheeksi et voi käyttää puhepalvelun API-avainta suoraan, vaan sinun täytyy pyytää käyttöoikeustunnus, käyttäen API-avainta autentikoimaan käyttöoikeustunnuspyynnön. Avaa __init__.py-tiedosto text-to-speech-kansiosta ja korvaa kaikki sen koodi seuraavalla:

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ä määrittää vakioita sijainnille ja puheavaimelle, jotka luetaan asetuksista. Se määrittää myös get_access_token-funktion, joka hakee käyttöoikeustunnuksen puhepalvelulle.

Lisää tämän koodin alle seuraava:

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ä määrittää HTTP-triggerin, joka muuntaa tekstin puheeksi. Se poimii tekstin, kielen ja äänen JSON-rungosta, joka on lähetetty pyyntöön, rakentaa SSML:n puhepyyntöä varten, ja kutsuu asiaankuuluvaa REST-API:a autentikoiden käyttöoikeustunnuksella. Tämä REST-API-kutsu palauttaa äänen koodattuna 16-bittiseksi, 48KHz mono WAV-tiedostoksi, joka on määritelty playback_format-arvolla, joka lähetetään REST-API-kutsuun.

Tämä uudelleennäytteistetään librosa-kirjastolla näytteenottotaajuudesta 48KHz näytteenottotaajuuteen 44.1KHz, ja tämä ääni tallennetaan binaariseen puskuriin, joka sitten palautetaan.

Aja funktiosovelluksesi paikallisesti tai julkaise se pilveen. Voit sitten kutsua tätä työkalulla, kuten curl, samalla tavalla kuin testasit text-to-timer HTTP-triggeriä. Muista välittää kieli, ääni ja teksti JSON-runkona:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Korvaa <language> kielelläsi, kuten en-GB tai zh-CN. Korvaa <voice> haluamallasi äänellä. Korvaa <text> tekstillä, jonka haluat muuttaa puheeksi. Voit tallentaa tuloksen tiedostoon ja toistaa sen millä tahansa WAV-tiedostoja toistavalla audioplayerilla.

Esimerkiksi muuntaaksesi "Hello" puheeksi käyttäen Yhdysvaltain englantia ja Jenny Neural -ääntä, kun funktiosovellus on käynnissä paikallisesti, voit käyttää seuraavaa curl-komentoa:
```
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ä tallentaa äänen hello.wav-tiedostoon nykyisessä hakemistossa.