24 KiB

Raw Permalink Blame History

Teks ke Ucapan - Wio Terminal

Dalam bahagian pelajaran ini, anda akan menukar teks kepada ucapan untuk memberikan maklum balas secara lisan.

Teks ke Ucapan

SDK perkhidmatan ucapan yang anda gunakan dalam pelajaran sebelumnya untuk menukar ucapan kepada teks juga boleh digunakan untuk menukar teks kembali kepada ucapan.

Dapatkan Senarai Suara

Apabila meminta ucapan, anda perlu menyediakan suara yang akan digunakan kerana ucapan boleh dihasilkan menggunakan pelbagai jenis suara. Setiap bahasa menyokong pelbagai suara, dan anda boleh mendapatkan senarai suara yang disokong untuk setiap bahasa daripada SDK perkhidmatan ucapan. Keterbatasan mikropengawal memainkan peranan di sini - panggilan untuk mendapatkan senarai suara yang disokong oleh perkhidmatan teks ke ucapan adalah dokumen JSON berukuran lebih 77KB, terlalu besar untuk diproses oleh Wio Terminal. Pada masa penulisan, senarai penuh mengandungi 215 suara, setiap satu ditakrifkan oleh dokumen JSON seperti berikut:

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

JSON ini adalah untuk suara Aria, yang mempunyai pelbagai gaya suara. Apa yang diperlukan apabila menukar teks kepada ucapan hanyalah nama pendek, en-US-AriaNeural.

Daripada memuat turun dan menyahkod keseluruhan senarai ini pada mikropengawal anda, anda perlu menulis beberapa kod tanpa pelayan untuk mendapatkan senarai suara bagi bahasa yang anda gunakan, dan memanggil ini dari Wio Terminal anda. Kod anda kemudian boleh memilih suara yang sesuai daripada senarai, seperti suara pertama yang dijumpai.

Tugasan - Cipta Fungsi Tanpa Pelayan untuk Mendapatkan Senarai Suara

Buka projek smart-timer-trigger anda dalam VS Code, dan buka terminal dengan memastikan persekitaran maya diaktifkan. Jika tidak, matikan dan buat semula terminal.
Buka fail local.settings.json dan tambahkan tetapan untuk kunci API ucapan dan lokasi:
```
"SPEECH_KEY": "<key>",
"SPEECH_LOCATION": "<location>"
```
Gantikan <key> dengan kunci API untuk sumber perkhidmatan ucapan anda. Gantikan <location> dengan lokasi yang anda gunakan semasa mencipta sumber perkhidmatan ucapan.
Tambahkan pencetus HTTP baharu pada aplikasi ini yang dipanggil get-voices menggunakan arahan berikut dari dalam terminal VS Code di folder akar projek aplikasi fungsi:
```
func new --name get-voices --template "HTTP trigger"
```
Ini akan mencipta pencetus HTTP yang dipanggil get-voices.

Gantikan kandungan fail __init__.py dalam folder get-voices dengan yang berikut:

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)

Kod ini membuat permintaan HTTP ke titik akhir untuk mendapatkan suara. Senarai suara ini adalah blok besar JSON dengan suara untuk semua bahasa, jadi suara untuk bahasa yang dihantar dalam badan permintaan ditapis, kemudian nama pendek diekstrak dan dikembalikan sebagai senarai JSON. Nama pendek adalah nilai yang diperlukan untuk menukar teks kepada ucapan, jadi hanya nilai ini yang dikembalikan.

💁 Anda boleh mengubah penapis mengikut keperluan untuk memilih hanya suara yang anda inginkan.

Ini mengurangkan saiz data daripada 77KB (pada masa penulisan), kepada dokumen JSON yang jauh lebih kecil. Sebagai contoh, untuk suara AS ini adalah 408 bait.

Jalankan aplikasi fungsi anda secara tempatan. Anda kemudian boleh memanggil ini menggunakan alat seperti curl dengan cara yang sama seperti anda menguji pencetus HTTP text-to-timer anda. Pastikan untuk menghantar bahasa anda sebagai badan JSON:
```
{
    "language":"<language>"
}
```
Gantikan <language> dengan bahasa anda, seperti en-GB, atau zh-CN.

💁 Anda boleh menemui kod ini dalam folder code-spoken-response/functions.

Tugasan - Dapatkan Suara dari Wio Terminal Anda

Buka projek smart-timer dalam VS Code jika belum dibuka.
Buka fail header config.h dan tambahkan URL untuk aplikasi fungsi anda:
```
const char *GET_VOICES_FUNCTION_URL = "<URL>";
```
Gantikan <URL> dengan URL untuk pencetus HTTP get-voices pada aplikasi fungsi anda. Ini akan sama dengan nilai untuk TEXT_TO_TIMER_FUNCTION_URL, kecuali dengan nama fungsi get-voices dan bukannya text-to-timer.
Cipta fail baharu dalam folder src yang dipanggil text_to_speech.h. Ini akan digunakan untuk mentakrifkan kelas untuk menukar dari teks kepada ucapan.

Tambahkan arahan include berikut di bahagian atas fail text_to_speech.h baharu:

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

Tambahkan kod berikut di bawah ini untuk mengisytiharkan kelas TextToSpeech, bersama dengan satu instance yang boleh digunakan dalam aplikasi lain:
```
class TextToSpeech
{
public:
private:
};

TextToSpeech textToSpeech;
```
Untuk memanggil aplikasi fungsi anda, anda perlu mengisytiharkan klien WiFi. Tambahkan yang berikut ke bahagian private kelas:
```
WiFiClient _client;
```
Dalam bahagian private, tambahkan medan untuk suara yang dipilih:
```
String _voice;
```
Ke bahagian public, tambahkan fungsi init yang akan mendapatkan suara pertama:
```
void init()
{
}
```
Untuk mendapatkan suara, dokumen JSON perlu dihantar ke aplikasi fungsi dengan bahasa. Tambahkan kod berikut ke fungsi init untuk mencipta dokumen JSON ini:
```
DynamicJsonDocument doc(1024);
doc["language"] = LANGUAGE;

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

Seterusnya, cipta HTTPClient, kemudian gunakannya untuk memanggil aplikasi fungsi untuk mendapatkan suara, menghantar dokumen JSON:

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

int httpResponseCode = httpClient.POST(body);

Di bawah ini, tambahkan kod untuk memeriksa kod respons, dan jika ia adalah 200 (berjaya), maka ekstrak senarai suara, mendapatkan suara pertama dari senarai:

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

Selepas ini, tamatkan sambungan klien HTTP:
```
httpClient.end();
```
Buka fail main.cpp, dan tambahkan arahan include berikut di bahagian atas untuk memasukkan fail header baharu ini:
```
#include "text_to_speech.h"
```
Dalam fungsi setup, di bawah panggilan ke speechToText.init();, tambahkan yang berikut untuk memulakan kelas TextToSpeech:
```
textToSpeech.init();
```

Bina kod ini, muat naik ke Wio Terminal anda dan uji melalui monitor bersiri. Pastikan aplikasi fungsi anda sedang berjalan.

Anda akan melihat senarai suara yang tersedia dikembalikan dari aplikasi fungsi, bersama dengan suara yang dipilih.

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

Tukar Teks ke Ucapan

Setelah anda mempunyai suara untuk digunakan, ia boleh digunakan untuk menukar teks kepada ucapan. Keterbatasan memori yang sama dengan suara juga berlaku semasa menukar ucapan kepada teks, jadi anda perlu menulis ucapan ke kad SD untuk dimainkan melalui ReSpeaker.

💁 Dalam pelajaran sebelumnya dalam projek ini, anda menggunakan memori flash untuk menyimpan ucapan yang dirakam dari mikrofon. Pelajaran ini menggunakan kad SD kerana lebih mudah untuk memainkan audio daripadanya menggunakan perpustakaan audio Seeed.

Terdapat juga satu lagi keterbatasan yang perlu dipertimbangkan, data audio yang tersedia dari perkhidmatan ucapan, dan format yang disokong oleh Wio Terminal. Tidak seperti komputer penuh, perpustakaan audio untuk mikropengawal boleh sangat terhad dalam format audio yang mereka sokong. Sebagai contoh, perpustakaan Seeed Arduino Audio yang boleh memainkan bunyi melalui ReSpeaker hanya menyokong audio pada kadar sampel 44.1KHz. Perkhidmatan ucapan Azure boleh menyediakan audio dalam beberapa format, tetapi tiada satu pun daripadanya menggunakan kadar sampel ini, mereka hanya menyediakan 8KHz, 16KHz, 24KHz dan 48KHz. Ini bermakna audio perlu disampel semula kepada 44.1KHz, sesuatu yang memerlukan lebih banyak sumber daripada yang dimiliki oleh Wio Terminal, terutamanya memori.

Apabila perlu memanipulasi data seperti ini, lebih baik menggunakan kod tanpa pelayan, terutamanya jika data diperoleh melalui panggilan web. Wio Terminal boleh memanggil fungsi tanpa pelayan, menghantar teks untuk ditukar, dan fungsi tanpa pelayan boleh memanggil perkhidmatan ucapan untuk menukar teks kepada ucapan, serta menyampel semula audio kepada kadar sampel yang diperlukan. Ia kemudian boleh mengembalikan audio dalam bentuk yang diperlukan oleh Wio Terminal untuk disimpan pada kad SD dan dimainkan melalui ReSpeaker.

Tugasan - Cipta Fungsi Tanpa Pelayan untuk Menukar Teks ke Ucapan

Buka projek smart-timer-trigger anda dalam VS Code, dan buka terminal dengan memastikan persekitaran maya diaktifkan. Jika tidak, matikan dan buat semula terminal.
Tambahkan pencetus HTTP baharu pada aplikasi ini yang dipanggil text-to-speech menggunakan arahan berikut dari dalam terminal VS Code di folder akar projek aplikasi fungsi:
```
func new --name text-to-speech --template "HTTP trigger"
```
Ini akan mencipta pencetus HTTP yang dipanggil text-to-speech.
Pakej Pip librosa mempunyai fungsi untuk menyampel semula audio, jadi tambahkan ini ke fail requirements.txt:
```
librosa
```
Setelah ini ditambahkan, pasang pakej Pip menggunakan arahan berikut dari terminal VS Code:
```
pip install -r requirements.txt
```
⚠️ Jika anda menggunakan Linux, termasuk Raspberry Pi OS, anda mungkin perlu memasang libsndfile dengan arahan berikut:
```
sudo apt update
sudo apt install libsndfile1-dev
```

Untuk menukar teks kepada ucapan, anda tidak boleh menggunakan kunci API ucapan secara langsung, sebaliknya anda perlu meminta token akses, menggunakan kunci API untuk mengesahkan permintaan token akses. Buka fail __init__.py dari folder text-to-speech dan gantikan semua kod di dalamnya dengan yang berikut:

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)

Ini mentakrifkan pemalar untuk lokasi dan kunci ucapan yang akan dibaca dari tetapan. Ia kemudian mentakrifkan fungsi get_access_token yang akan mendapatkan token akses untuk perkhidmatan ucapan.

Di bawah kod ini, tambahkan yang berikut:

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)

Ini mentakrifkan pencetus HTTP yang menukar teks kepada ucapan. Ia mengekstrak teks untuk ditukar, bahasa dan suara dari badan JSON yang dihantar ke permintaan, membina beberapa SSML untuk meminta ucapan, kemudian memanggil REST API yang relevan dengan mengesahkan menggunakan token akses. Panggilan REST API ini mengembalikan audio yang dikodkan sebagai fail WAV mono 16-bit, 48KHz, yang ditakrifkan oleh nilai playback_format, yang dihantar ke panggilan REST API.

Ini kemudian disampel semula oleh librosa dari kadar sampel 48KHz kepada kadar sampel 44.1KHz, kemudian audio ini disimpan ke penimbal binari yang kemudian dikembalikan.

Jalankan aplikasi fungsi anda secara tempatan, atau gunakan ke awan. Anda kemudian boleh memanggil ini menggunakan alat seperti curl dengan cara yang sama seperti anda menguji pencetus HTTP text-to-timer anda. Pastikan untuk menghantar bahasa, suara dan teks sebagai badan JSON:
```
{
    "language": "<language>",
    "voice": "<voice>",
    "text": "<text>"
}
```
Gantikan <language> dengan bahasa anda, seperti en-GB, atau zh-CN. Gantikan <voice> dengan suara yang anda ingin gunakan. Gantikan <text> dengan teks yang anda ingin tukar kepada ucapan. Anda boleh menyimpan output ke fail dan memainkannya dengan mana-mana pemain audio yang boleh memainkan fail WAV.

Sebagai contoh, untuk menukar "Hello" kepada ucapan menggunakan Bahasa Inggeris AS dengan suara Jenny Neural, dengan aplikasi fungsi berjalan secara tempatan, anda boleh menggunakan arahan curl berikut:
```
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"
     }'
```
Ini akan menyimpan audio ke hello.wav dalam direktori semasa.