Configurazione dei Players
Il Players è la libreria/software usato per far parlare Kalliope.
In un progetto Kalliope, puoi impostare qualsiasi lettore audio che desideri utilizzare.
default_playerSpecificare il nome del modulo Players che si desidera utilizzare.
default_player : "player_name"
Per esempio
default_player : "mplayer"
playersOgni players ha la propria configurazione.
Questa configurazione è passata come argomento seguendo la seguente sintassi
players:
- player_name:
parameter_name: "value"
Quando non sono richiesti parametri, imposta un oggetto vuoto:
players:
- mplayer: {}
Esempio d'impostazioni players:
- mplayer: {}
- pyalsaaudio:
device: "default"
convert_to_wav: True
- pyaudioplayer:
convert_to_wav: True
- sounddeviceplayer:
convert_to_wav: True
Nota: A volte, i parametri saranno necessari per utilizzare un engine.
Fai clic sul link del Player scelto nella sezione "Current CORE Available Players" per sapere quali parametri sono richiesti.
Nota: Un player che non richiede Parametri d'input deve essere dichiarato con un dict vuoto. Ad esempio: - player_name: {}
Nota: I player principali sono inclusi nell'installazione di Kalliope e sono pronti all'uso.
Nota: La maggior parte dei TTS basati su cloud genera un file in formato MP3. Alcuni players non sono in grado di leggere questo formato e quindi è necessaria una conversione in wav.
Players disponibiliI player principali sono già stati confezionati con Kalliope e possono essere utilizzati sin da subito.
| Doc | Note |
| ------------------------------------------------- | --------------------------------------------------------------------------------------------- |
| [mplayer](players/mplayer.md) | Basato sul [software mplayer](
http://www.mplayerhq.hu/design7/news.html) |
| [pyalsaaudio](players/pyalsaaudio.md) | Basato sula lib di [pyalsaaudio](
https://larsimmisch.github.io/pyalsaaudio/libalsaaudio.html) |
| [pyaudioplayer](players/pyaudioplayer.md) | Basato sula lib di [pyaudio](
https://people.csail.mit.edu/hubert/pyaudio/docs/) |
| [sounddeviceplayer](players/sounddeviceplayer.md) | Basato sula lib di [sounddevice](
https://pypi.python.org/pypi/sounddevice) |
Configurazione della Sintesi Vocale
default_speech_to_textUno Speech To Text(STT) è un engine utilizzato per tradurre ciò che dici in un testo che può essere elaborato dal core di Kalliope.
Per impostazione predefinita, Kalliope utilizza il motore Google STT.
La seguente sintassi viene utilizzata per fornire il nome dell'engine:
default_speech_to_text: "stt_name"
Per esempio
default_speech_to_text: "google"
speech_to_text
Ogni STT ha la propria configurazione. Questa configurazione è passata come argomento che viene mostrato di seguito
speech_to_text:
- stt_name:
parameter_name: "value"
Per esempio:
speech_to_text:
- google :
language: "it-IT"
- Bing
Esempio d'impostazioni
default_speech_to_text: "google"
speech_to_text:
- google:
language: "it-IT"
- wit:
key: "MYKEYS"
- bing:
key: "MYKEYS"
- apiai:
key: "MYKEYS"
language: "it"
- houndify:
key: "MYKEYS"
client_id: "MYCLIENTID"
STT disponibiliI principali STTs sono già stati inclusi con l'installazione di Kalliope e sono pronti all'uso.
| Nome | Tipo |
| ----------------------------- | --------------------- |
| [apiai](stt/api.ai.md) | Basato su cloud |
| [Bing](stt/bing.md) | Basato su cloud |
| [CMUSphinx](stt/CMUSphinx.md) | Self hosted (Offline) |
| [Google](stt/google.md) | Basato su cloud |
| [Houndify](stt/houndify.md) | Basato su cloud |
| [wit.ai](stt/wit.ai.md) | Basato su cloud |
Configurazione Sintesi Vocale
default_text_to_speechIl Text To Speech è utilizzato per tradurre il testo scritto in un flusso audio.
Per impostazione predefinita, Kalliope utilizza l'engine TTS Pico2wave.
La seguente sintassi viene utilizzata per fornire il nome dell'engine TTS
default_text_to_speech: "tts_name"
Per esempio
default_text_to_speech: "pico2wave"
text_to_speechOgni TTS ha la propria configurazione. Questa configurazione è passata come argomento seguendo la seguente sintassi
text_to_speech :
- tts_name :
parameter_name: "value"
Per esempio
text_to_speech :
- pico2wave :
language: "it-IT"
- googletts :
language: "it-IT"
cache_pathGli engines TTS funzionano tutti allo stesso modo, gli diamo un testo, restituiscono un file audio e riproducono il file audio. Il file audio generato viene inserito nella cache fino a quando non
viene riprodotto dal lettore audio. Prima di generare un nuovo file audio, Kalliope darà un'occhiata alla cache per caricarla direttamente senza dover chiamare il
motore TSS se il file è gia stato generato in precedenza.
È necessario impostare, nel tag `cache_path`, un percorso in cui la cache verrà salvata. Di default il percorso è /tmp.
cache_path: "/ tmp / kalliope_tts_cache"
Nota: Il percorso deve essere valido e l'utente deve averne i permessi di lettura e scrittura.
Nota: Lo spazio occupato aumenta notevolmente a causa della cache. Si consiglia di impostare un neurone che cancelli automaticamente i file audio
generati che non verrano più riprodotti.
Esempio d'impostazioni default_text_to_speech: "voicerss"
cache_path: "/tmp/kalliope_tts_cache"
text_to_speech :
- pico2wave :
language: "it-IT"
cache: True
- acapela:
language: "sonid15"
voce : "Manon"
cache : False
- googletts :
language: "it"
- voicers :
language: "it-IT"
cache: True
TTS disponibili
I principali TTS sono già inclusi nell'installazione di Kalliope e possono essere utilizzati immediatamente.
| Name | Tipo |
| ----------------------------- | --------------------- |
| [espeak](tts/espeak.md) | Self hosted (Offline) |
| [googletts](tts/googletts.md) | Basato su cloud |
| [marytts](tts/marytts.md) | Self hosted (Offline) |
| [pico2wave](tts/pico2wave.md) | Self hosted (Offline) |
| [voicerss](tts/voicerss.md) | Basato su cloud |
| [watson](tts/watson.md) | Basato su cloud |
Hooks
L'Hooking consente di associare le azioni agli eventi in base al lifecycle di Kalliope.
Ad esempio, è utile sapere quando Kalliope ha rilevato l'hotword dal trigger engine e farle pronunciare ad alta voce che è pronta ad ascoltare il tuo ordine.
Per utilizzare un hook, collega il nome dell'hook a una sinapsi (o un elenco di sinapsi) esistenti nel tuo brain.
Sintassi:
hooks:
hook_name1 : sinapse_name
hook_name2 :
- synapse_name_1
- synapse_name_2
Per esempio
hooks:
on_start : "on-start-synapse"
Elenco degli hook disponibili| Nome dell'hook | Descrizione |
| ---------------------- | ---------------------------------------------------------------------- |
| on_start | Quando viene avviato kalliope. Questo hook si attiva una sola volta |
| on_waiting_for_trigger | Quando Kalliope attende il rilevamento di hotword |
| on_triggered | Quando è stata rilevata l'hotword |
| on_start_listening | Quando il motore di sintesi vocale è in ascolto di un ordine |
| on_stop_listening | Quando il motore di sintesi vocale interrompe l'attesa di un ordine |
| on_order_found | Quando l'ordine pronunciato è stato trovato nel brain |
| on_order_not_found | Quando l'ordine pronunciato non è stato trovato nel brain |
| on_processed_synapses | Quando tutti i neuroni nelle sinapsi sono stati elaborati |
| on_deaf | Quando Kalliope passa da non udente a udente |
| on_undeaf | Quando Kalliope passa da udente a non udente |
| on_mute | Quando Kalliope passa da non muto a muto |
| on_unmute | Quando Kalliope passa da muto a non muto |
| on_start_speaking | uando Kalliope inizia a parlare attraverso il motore di sintesi vocale |
| on_stop_speaking | Quando Kalliope smette di parlare |
| on_stt_error | Quando avviane un errore durante l'elaborazione dell'STT |
Esempio d'impostazioniEsempio: vuoi sentire una risposta casuale quando è rilevata l'hotword
settings.yml hooks:
on_triggered : "on-triggered-synapse"
[b]brain.yml[/b]
- name: "on-triggered-synapse"
signals: []
neurons:
- say:
message:
- "si signore?"
- "Sto ascoltando"
- "Sto ascoltando te"
- "signore?"
- "cosa posso fare per te?"
- "Parlare"
- "come posso Aiutare te?"
Esempio: vuoi sapere che il tuo ordine non è stato trovato
settings.yml hooks:
on_order_not_found: "order-not-found-synapse"
[b]brain.yml[/b]
- name: "order-not-found-synapse"
signals: []
neurons:
- say:
message:
- "I non ho compreso"
- "I non conosco Questo ordine"
- "Per favore ripetere il tuo ordine"
- "Per favore riformulare il tuo ordine"
- "Io non riconosco quello ordine"
Esempio: stai usando Kalliope su un Rpi. Hai realizzato uno script che attiva o disattiva un led.
Puoi chiamare questo script ogni volta che kalliope inizia o smette di parlare
settings.yaml hooks:
on_start_speaking : "turn-on-led"
on_stop_speaking : "turn-off-led"
[b]brain.yml[/b]
- name: "turn-on-led"
signals: []
neurons:
- script:
path: "/path/to/script.sh on"
- name: "turn-off-led"
signals: []
neurons:
- script:
path: "/path/to/script.sh off"
Nota: non è possibile utilizzare un neurotrasmettitore all'interno di una sinapsi chiamata da un hook.
Non puoi usare il neurone "say" all'interno di "on_start_speaking" o "on_stop_speaking" o creerà un loop infinito
Rest API
È possibile attivare una Rest API per:
- Elencare le sinapsi
- Ottenere i dettagli delle sinapsi
- Eseguire una sinapsi
- Aggiornare le impostazioni
- Aggiornare il brain
Per la lista completa delle API vedi la documentazione REST API
https://kalliope-project.github.io/kalliope/rest_api/Esempi di impostazioni:
rest_api:
active: True
port: 5000
password_protected: True
login: admin
password: secret
allowed_cors_origin: "*"
| Parametro | Tipo | Commento |
| ------------------- | -------- | ---------------------------------------------------------------------------------------------------------- |
| active | booleano | Per abilitare il server rest api |
| port | intero | La porta in ascolto del server web. Deve essere un numero intero compreso tra 1024-65535 |
| password_protected | booleano | Se `True`, l'intera API sarà protetta da password |
| login | stringa | Accesso protetto dall'autenticazione HTTP di base. Deve essere fornito se `password_protected` è `True` |
| password | stringa | Password utilizzata dall'autenticazione HTTP di base. Deve essere fornito se `password_protected` è `True` |
| allowed_cors_origin | stringa | Consenti richiesta da applicazione esterna. Vedi gli esempi qui sotto |
Richieste CorsSe si desidera consentire le richieste da un'applicazione esterna, è necessario abilitare le impostazioni delle richieste CORS definendo le origini autorizzate.
Per fare ciò, basta indicare l'origine a cui è consentito sfruttare l'API. I valori autorizzati sono:
False per vietare la richiesta CORS.
allowed_cors_origin : False
o anche una stringa o un elenco:
allowed_cors_origin: "*"
(in caso di "*", tutte le origini sono accettate).
allowed_cors_origin:
- 'http://mydomain.com/*'
- 'http://localhost:4200/*'
Ricorda che un'origine è composta dallo schema (http(s)), dalla porta (es.:80, 4200,…) e dal dominio (mydomain.com, localhost).
Directory delle risorse
La directory delle risorse è il percorso in cui Kalliope proverà a caricare moduli della community come Neuroni, STT o TTS.
È necessario impostare un percorso valido se si desidera installare dei "community neuron". Il percorso può essere relativo o assoluto.
resource_directory :
resource_name: "path"
Per esempio
resource_directory :
neuron: "resources/neurons"
stt: "resources/stt"
tts: "resources/tts"
trigger: "/full/path/to/trigger"
Variabili Globali
I percorsi delle Variabili Globali elencano dove caricare le suddette.
Queste variabili possono essere riutilizzate nei parametri dei neuroni dentro parentesi doppie.
Per esempio
var_files:
- variables.yml
- variables2.yml
Nota: Se una variabile è definita in file diversi, l'ultimo file definisce il valore.
Nei file le variabili sono definite da key/value:
variable: 60
baseURL: "
http://blabla.com/"
password: "secret"
E cosi si usano nei tuoi neurons:
- name: "run-simple-sleep"
signals:
- order: "Aspettami"
neurons:
- uri:
url: "{{baseURL}}get/1"
user: "admin"
password: "{{password}}"
Nota: poiché il formato YAML non consente doppie parentesi non circondate da virgolette: è necessario utilizzare la variabile tra virgolette.
Una variabile globale può essere un dizionario. Esempio:
contatti :
nico : "1234"
francesco : "5678"
E una sinapsi che usa questo dizionario:
- name: "test-var"
signals:
- order: "dammi il numero di {{ contact_to_search }}"
neurons:
- say:
message:
- "il numero è {{ contacts[contact_to_search] }}"
Opzioni
Opzioni che possono essere definite per Kalliope.
Esempio di configurazione
options:
mute: True
deaf: False
Opzioni disponibili:
| Opzione | Descrizione |
| ------------------------------- | ---------------------------------------------------------------------------------------------------- |
| mute | Quando è muto, l'STT engine non sarà usato per far parlare Kalliope durante l'esecuzione dei neuroni |
| deaf | Quando è sordo, il trigger engine non viene avviato. Kalliope non aspetterà la wake up word |
| energy_threshold | [energy_threshold](#energy_threshold) |
| adjust_for_ambient_noise_second | [adjust_for_ambient_noise_second](#adjust_for_ambient_noise_second) |
| stt_timeout | Numero di secondi prima di interrompere automaticamente l'esecuzione dell'STT |
energy_thresholdRappresenta la soglia del rumore ambientale. Di default è impostato su 4000 .
I valori al di sotto di questa soglia sono considerati silenzio e i valori superiori a questa soglia sono considerati voce.
Questo viene regolato automaticamente se le soglie dinamiche sono abilitate con il parametro adjust_for_ambient_noise_second .
Questa soglia è associata al volume percepito del suono, ma è una relazione non lineare.
La soglia di energia effettiva necessaria dipende dalla sensibilità del microfono o dai dati audio.
I valori tipici per una stanza silenziosa sono compresi tra 0 e 100 e i valori tipici per la conversazione sono compresi tra 150 e 3500.
Il rumore ambientale (non parlato) ha un impatto significativo su quali valori funzioneranno meglio.
Se hai problemi con il riconoscimento che cerca di riconoscere le parole anche quando non parli, prova a modificarlo con un valore più alto.
Se hai problemi di non riconoscimento delle tue parole mentre parli, prova a modificarlo con un valore più basso.
Ad esempio, un microfono sensibile o un microfono in stanze più rumorose potrebbe avere un livello di energia ambientale maggiore di 4000.
options:
energy_threshold: 4000
Nota: Il valore predefinito, se non impostato, è 4000
adjust_for_ambient_noise_secondSe definito, calibra la soglia in modo dinamico acquisendo il rumore ambientale della stanza per la durata in secondi impostata nel parametro.
Quando è impostato, il parametro energy_threshold viene sovrascritto dal valore restituito dalla calibrazione del rumore.
Questo valore dovrebbe essere almeno 0,5 per ottenere un campione rappresentativo del rumore ambientale.
options:
adjust_for_ambient_noise_second: 1
Nota: Il numero di secondi qui rappresenta il tempo tra il risveglio di Kalliope e il momento in cui puoi darle il tuo ordine.
send_anonymous_usage_statsQuesto flag consente a Kalliope di inviare alcune statistiche per valutare in modo anonimo l'utilizzo globale dell'app Kalliope da parte degli utenti.
Sintassi:
send_anonymous_usage_stats: <boolean>
Per esempio:
send_anonymous_usage_stats: False
Trigger
Snowboy
Sommario
parametri
Impostazioni d'esempio
Modelli disponibili di Snowboy
Parametri
Puoi creare la tua hotword collegandoti a Snowboy
https://snowboy.kitt.ai/ e poi scaricare il file generato che fungerà da modello.
Una volta scaricato, posiziona il file nella tua cartella config personale e imposta snowboy con la seguente tabella
| parametro |necessario| tipo | default | valori possibili| commento |
|-------------|----------|--------|---------|-----------------|----------------------------------------------------------------------------------------------------------------------------------|
| pmdl_file | TRUE | stringa| | | Percorso del file del modello Snowboy. Il percorso può essere assoluto o relativo al file brain |
| sensitivity | FALSE | stringa| 0.5 | tra 0 e 1 | Aumentando il valore di sensibilità si ottiene una migliore velocità di rilevamento, ma anche un più alto tasso di falsi allarmi |
Impostazioni d'esempio
# Questo è il trigger che catturerà la tua hotword per svegliare Kalliope. Solo Snowboy è disponibile finora
default_trigger: "snowboy"
# Caricare la configurazione del trigger
triggers:
- snowboy:
pmdl_file: "trigger/snowboy/resources/kalliope-FR-40samples.pmdl"
Modelli Snowboy disponibili
Se vuoi mantenere "Kalliope" come nome del tuo bot,
ti consigliamo di migliorare il modello Snowboy esistente per la tua lingua .Aggiorneremo il seguente elenco con tutti i modelli che la comunità ha creato per Kalliope. Se il modello non esiste, crearne uno con la seguente sintassi:
kalliope-<language_code>
Per esempio
Kalliope-FR
Kalliope-IT
Kalliope-RU
Kalliope-DE
Kalliope-IT
Quindi, apri una "issue" o crea una "pull request" per aggiungere il modello all'elenco seguente.
Nota importante: Non migliorare un modello nella lingua sbagliata. Controlla la pronuncia prima di registrare la tua voce!
| Nome | lingua | Pronuncia |
|------------------------------------------------------|----------|--------------|
| [kalliope-FR](
https://snowboy.kitt.ai/hotword/1363) | Francese | Ka-lio-pé |
| [kalliope-EN](
https://snowboy.kitt.ai/hotword/2540) | Inglese | kə-LIE-ə-pee |
| [kalliope-RU](
https://snowboy.kitt.ai/hotword/2964) | Russo | каллиопа |
| [kalliope-DE](
https://snowboy.kitt.ai/hotword/4324) | Tedesco | Ka-lio-pe |
| [kalliope-IT](
https://snowboy.kitt.ai/hotword/10650) | Italiano | Ka-lljo-pe |
Player
Sommario
Parametri d'input
Esempio d'impostazioni
Note
mplayer
Player predefinito di kalliope. Questo Player è basato suli'engine mplayer
Parametri d'input
Nessun parametro richiesto
Esempio d'impostazioni
default_player: "mplayer"
players:
- mplayer: {}
Note
Nota: Questo lettore gestisce sia il formato mp3 che wav.
pyalsaaudio
Questo Player è basato sul engine alsa
Parametri d'input
| parametro |necessario| default |valori possibili| commento |
|----------------|----------|-----------|----------------|-----------------------------------------------------------|
| device | no | "default" | | Seleziona il dispositivo da usare per alsa |
| convert_to_wav | no | TRUE | True, False | Converti il file generato dal TTS in wav prima di leggere |
Esempio d'impostazioni
Ecco un esempio di configurazione che useresti se il tuo TTS fosse acapela. Poiché questo TTS genera un file MP3, quest'ultimo deve essere convertito in wav.
default_player: "pyalsaaudio"
players:
- pyalsaaudio:
device: "default"
convert_to_wav: True
Note
Nota: Definire la scheda predefinita da utilizzare nel parametro device . Ad esempio, su un Raspberry Pi, la scheda predefinita può essere sysdefault:CARD=ALSA
Nota: Questo lettore non gestisce il formato mp3, la conversione da mp3 in wav potrebbe essere necessaria se il engine TTS selezionato genera file mp3.
pyaudioplayer
Questo lettore è basato sull'engine pyaudio
Parametri d'input
| parametro |necessario| default |valori possibili| commento |
|----------------|----------|---------|----------------|-----------------------------------------------------------|
| convert_to_wav | no | TRUE | True, False | Converti il file generato dal TTS in wav prima di leggere |
Esempio d'impostazioni
default_player: "pyaudioplayer"
players:
- pyaudioplayer:
convert_to_wav: True
Note
Nota: Questo lettore non gestisce il formato mp3, potrebbe essere richiesta la conversione da mp3 in wav.
sounddeviceplayer
Questo lettore è basato su engines sounddevice e soundfile
Parametri d'input
| parametro |necessario| default |valori possibili| commento |
|----------------|----------|---------|----------------|-----------------------------------------------------------|
| convert_to_wav | no | TRUE | True, False | Converti il file generato dal TTS in wav prima di leggere |
Esempio d'impostazioni
default_player: "sounddeviceplayer"
players:
- sounddeviceplayer:
convert_to_wav: True
Note
Nota: Questo lettore non gestisce il formato mp3, è richiesta la conversione da mp3 in wav.
STT
Sommario
Parametri d'input
Esempio d'impostazioni
api.ai
L'STT api.ai si basa sull'API api.ai
Parametri d'input
| parametro |necessario| default | valori possibili | commento |
|-----------|----------|---------|--------------------------------------------|---------------------|
| key | si | None | | Informazioni utente |
| language | no | en-US | [lang](
https://docs.api.ai/docs/languages) | |
Esempio d'impostazioni
default_speech_to_text: "apiai"
speech_to_text:
- apiai:
key: "0cbff154af44944a6"
language: "it"
Bing
L'STT Bing è basato sull'API Microsoft Recognition Voice di Bing
Parametri d'input
| parametro |necessario| default | valori possibili | commento |
|-----------|----------|---------|-----------------------------------------------------------------------|---------------------|
| key | SI | None | | Informazioni utente |
| language | No | en-US | [lang](
https://www.microsoft.com/cognitive-services/en-us/speech-api) | 7 languages |
Esempio d'impostazioni
default_speech_to_text: "bing"
speech_to_text:
- bing :
key: "9e48ddaf75904838bedc11aea6b36fb0"
language: "it"
CMUSphinx
Sommario
Installazione
Parametri d'input
Esempio d'impostazioni
Usando parole chiave
Questo modulo è una soluzione STT auto-ospitata (offline) basata sull'engine CMUSPhinx. Di base, è disponibile solo la lingua inglese. È possibile scaricare altre lingue dal repository principale e installarle seguendo la documentazione ufficiale .
Installazione
Installa i pacchetti
sudo apt-get install swig libpulse-dev
Quindi installa la lib per python
sudo pip installa pocketphinx
Parametri d'input
| Parametro |Necessario| Tipo | Default |Valori possibili| Commento |
| --------------- | -------- | ------- | ------- |----------------| --------------------------------------------------------------------------------------------------------------------------------------------- |
| language | no | stringa | en-US | | [Installare altre lingue](
https://github.com/Uberi/speech_recognition/blob/master/reference/pocketsphinx.rst#installing-other-languages) |
| keyword_entries | no | elenco | | | Elenco di tuple nella forma (keyword, sensitivity), dove keyword è una frase e sensitivity è la sensibilità al riconoscimento di questa frase |
| grammar_file | no | stringa | | | Percorso file grammaticali FSG o JSGF. Nota: se vengono passati `keyword_entries`, `grammar_file` verrà ignorato |
Esempio d'impostazioni
default_speech_to_text: "cmusphinx"
speech_to_text:
- cmusphinx :
language: "it-IT"
Usare le parole chiave
Sphinx di solito opera in "transcription mode" e restituirà tutte le parole che riconosce.
L'aggiunta di keyword_entries alle impostazioni restringe il suo spazio di ricerca ed è più accurata della semplice ricerca di quelle stesse parole chiave nelle trascrizioni non basate su parole chiave, perché Sphinx sa esattamente quali suoni cercare.
Il parametro keyword_entries prevede un elenco di tuple composto da una frase e un livello di sensibilità che definiscono la sensibilità di questa frase al riconoscitore, su una scala da 0 (molto insensibile, più falsi negativi) a 1 (molto sensibile, più falsi positivi).
default_speech_to_text: "cmusphinx"
speech_to_text:
- cmusphinx :
language: "it-IT"
keyword_entries:
- ["Ciao", 0.8]
- ["Ferma la musica", 0.6]
Google
L'STT di Google è basato sull'API Google Speech Recognition. Questo STT è gratuito per meno di 60 minuti di utilizzo al mese. Dopo ciò hai bisogno di un abbonamento.
Parametri d'input
| parametro |necessario| default | valori possibili | commento |
|-----------|----------|---------|-------------------------------------------------------------------------------|------------|
| key | No | None | | |
| language | No | en-US | [lang](
https://en.wikipedia.org/wiki/Google_Voice_Search#Supported_languages) |stringa LCID|
Esempio d'impostazioni
Utilizzo gratuito
default_speech_to_text: "google"
speech_to_text:
- google:
language: "it-IT"
Per gli utenti paganti
default_speech_to_text: "google"
speech_to_text:
- google:
language: "it-IT
key: "my_google_stt_key"
Houndify
Questo STT è basato sul engine Houndify .
Questo STT supporta solo l'inglese.
Parametri d'input
| parametro |necessario| default |valori possibili| commento |
|:---------:|----------|---------|----------------|-------------------|
| key | Yes | None | |Informazioni utente|
| client_id | Yes | None | |Informazioni utente|
Esempio d'impostazioni
default_speech_to_text: "houndify"
speech_to_text:
- houndify :
key: "my_user_key"
client_id : "my_user_client_id"
wit.ai
La wit STT è basata sull'API Wit.ai
Parametri d'input
| parametro |necessario| default |valori possibili| commento |
|:---------:|----------|---------|----------------|-------------------|
| key | Yes | None | |Informazioni utente|
Esempio d'impostazioni
default_speech_to_text: "wit"
speech_to_text:
- wit:
key: "my_user_key"
TTS
Sommario
Parametri d'input
Installazione
Esempio d'impostazioni
Note
eSpeak
Questo TTS è basato sull'engine eSpeak.
Parametri d'input
| Parametro |Necessario| Default | Valori possibili | Commento |
| ---------- | -------- | --------------- | ------------------------ | ------------------------------------------------------------------ |
| voice | si | | tutte le voci installate | guarda l'elenco completo con il comando "espeak --voices=LANGUAGE" |
| variant | no | |tutte le lingue installate| guarda l'elenco completo con il comando "espeak --voices=variant" |
| speed | no | 160 | 80 to 450 | Velocità in parole per minuto |
| amplitude | no | 100 | 0 to 200 | Ampiezza |
| pitch | no | 50 | 0 to 99 | Regolazione del pitc |
| path | no | /usr/bin/espeak | 0 to 99 | Percorso di espeak |
| cache | no | TRUE | | True se si desidera utilizzare la cache con questo TTS |
Installazione
Espeak deve essere installato con:
sudo apt-get install espeak
Per vedere l'elenco completo di lingue e voci:
espeak --voices
Per vedere l'elenco completo delle voci:
espeak --voices=LANGUAGE
Esempio:
espeak --voices=fr
Pty Language Age/Gender VoiceName File Other Languages
5 fr-fr M french fr (fr 5)
7 fr M french-mbrola-1 mb/mb-fr1
7 fr F french-mbrola-4 mb/mb-fr4
5 fr-be M french-Belgium europe/fr-be (fr
Configurazione per "7 fr M french-mbrola-1 mb/mb-fr1"
voice: "mb-fr1"
Per vedere l'elenco completo delle varianti:
espeak --voices=variant
Esempio:
espeak --voices=variant
Pty Language Age/Gender VoiceName File Other Languages
5 variant F female2 !v/f2
5 variant F female3 !v/f3
5 variant F female4 !v/f4
5 variant F female5 !v/f5
5 variant F female_whisper !v/whisperf
5 variant - klatt !v/klatt
5 variant - klatt2 !v/klatt2
[...]
Configurazione per "5 variant F female3 !v/f3".
voice: "fr"
variant: "f3"
Esempio d'impostazioni
default_text_to_speech: "espeak"
text_to_speech:
- espeak:
voice: "fr"
variant: "f3"
googletts
Questo TTS è basato sul Google translate engine
Parametri d'input
| Parametro |Necessario| Default | Valori possibili | Commento |
| ---------- | -------- | ------- | ----------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------- |
| language | YES | | [103 lingue](
http://translate.google.com/about/intl/en_ALL/languages.html) | Le lingue sono identificate con i loro codici ISO_639-1 (
https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes) |
| cache | No | TRUE | True / False | True se si desidera utilizzare la cache con questo TTS |
Esempio d'impostazioni
default_text_to_speech : "googletts"
text_to_speech:
- googletts:
language: "fr"
marytts
MaryTTS è una piattaforma open-source di sintesi vocale multilingue scritta in Java.
Parametri d'input
| Parametro |Necessario| Default | Valori possibili | Commento |
| ---------- | -------- | --------- | --------------------------------- | ------------------------------------------------------------------- |
| voice | si | None | es. bits1, cmu-bdl, enst-camille | Esegui "./marytts list" per controllare le voci installate |
| locale | si | None | es. de, en_US, fr | Controlla "
http://localhost:59125/locales" per le lingue installate |
| host | no | localhost | | Indirizzo host del tuo server MaryTTS |
| port | no | 59125 | | Porta del tuo server MaryTTS |
Esempio d'impostazioni
Per la voce inglese su localhost aggiungi le seguenti righe nel tuo settings.yml:
text_to_speech:
- marytts:
voice: "cmu-bdl"
locale: "en_US"
cache: True
Per voce inglese su host remoto con porta predefinita:
text_to_speech:
- marytts:
voice: "cmu-bdl"
locale: "en_US"
host: 192.168.0.25
cache: True
Note :
Nota: E' necessario installare il server Marytts .
pico2wave
Questo TTS è basato sull'engine SVOX picoTTS
Parametri d'input
| Parametro |Necessario| Default |Valori possibili| Commento |
| ---------- | -------- | ------------------ | -------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| language | si | | 6 lingue | Elenco delle lingue supportate nella sezione Note |
| cache | no | TRUE | True, False | True se si desidera utilizzare la cache con questo TTS |
| samplerate | no | | int | Pico2wave crea file da 16 khz ma non tutti i dispositivi USB supportano questo. Impostare un valore da convertire in un samplerate specifico. Ad esempio: 44100 |
| path | no | /usr/bin/pico2wave | | Percorso di Pico2wave. Se non impostato, Kalliope proverà a caricarlo dall'environment |
Esempio d'impostazioni
default_text_to_speech : "pico2wave"
text_to_speech:
- pico2wave:
language: "fr-FR"
cache: True
Note
Lingue supportate:
Inglese en-US
Inglese en-GB
Francese FR-FR
Spagnolo ES-ES
Tedesco de-DE
Italiano it-IT
voicerss
Questo TTS è basato sull'engine VoiceRSS. Documentazione ufficiale qui
Parametri d'input
| Parametro |Necessario| Default | Valori possibili | Commento |
| ------------ | -------- | -------------------- | ------------------------------------------------------------------------------- | -------------------------------------------------------- |
| language | SI | | [26 llingue](
http://www.voicerss.org/api/documentation.aspx), esempio : "fr-fr" | Le lingue sono identificate dalla stringa LCID |
| key | SI | | | registrati nel sito web ufficiale per ottenere la key API|
| rate | NO | 0 | qualunque intero "int" | Frequenza audio |
| codec | NO | 'MP3' | 'MP3', 'WAV', 'AAC', 'OGG', 'CAF' | Codec audio |
| audio_format | NO | '44khz_16bit_stereo' | [51 scelte](
http://www.voicerss.org/api/documentation.aspx), '8khz_8bit_mono' | Formati audio |
| ssml | NO | False | True / False | True se si desidera usare ssml (solo a pagamento) |
| base64 | NO | False | True / False | True se si desidera usare base64 |
| ssl | NO | False | True / False
