Kalliopé è un programma che ti permetterà di creare il tuo assistente vocale personale sul tuo Raspberry Pi.
Tradotto dalla Kalliope doc originale: https://kalliope-project.github.io/kalliope/
Home
Installation
Raspberry
Debian
Ubuntu
Getting-started
Settings
settings.yml
Trigger
Snowboy
Player
mplayer
pyalsaaudio
pyaudioplayer
sounddeviceplayer
STT
api.ai
Bing
CMUSphinx
Google
Houndify
wit.ai
TTS
espeak
googletts
marytts
pico2wave
voicerss
watson
Brain
brain.yml
Core signals
event
geolocation
mqtt_subscriber
order
Core neurons
ansible_playbook
brain
debug
kalliope_version
kill_switch
mqtt_publisher
neurotimer
neurotransmitter
say
script
settings
shell
signals
sleep
systemdate
uri
Community modules
CLI
API
Contribute
Core
Neuron
STT
TTS
Documentation
install.yml
dna.yml
Home
Benvenuti nella documentazione di Kalliope
Kalliope è un framework che ti aiuterà a creare il tuo assistente personale.
Il concetto è quello di creare il cervello https://kalliope-project.github.io/kalliope/brain/brain/ (https://kalliope-project.github.io/kalliope/brain/brain/)del tuo assistente collegando un signal di input (ordine vocale, evento programmato, messaggio MQTT, evento GPIO, ecc.) a una o più azioni chiamate neurons .
Puoi creare il tuo bot Kalliope, semplicemente scegliendo e componendo con i neuroni esistenti https://kalliope-project.github.io/neurons_marketplace.html (https://kalliope-project.github.io/neurons_marketplace.html) senza scrivere alcun codice. Ma se hai bisogno di un modulo particolare, puoi scriverlo da solo, aggiungerlo al tuo progetto e proporlo alla comunità.
Kalliope può funzionare su tutte le distribuzioni Linux basate su Debian incluso Raspberry Pi ed è multi-lingua. L'unica cosa di cui hai bisogno è un microfono.
Kalliope è facile da usare, guarda quest'hello world:
- name: "Ciao-puntotecnico"
signals:
- order: "dire Ciao"
neurons:
- say:
message: "Ciao puntotecnico!"
Installation
Raspberry
Requisiti di Kalliope per Raspbian
Kalliope può essere installato:
- Tramite l'immagine del disco precompilato
- Tramite script
- manualmente
Installa tramite l'immagine del disco precompilata
Scarica l'ultima immagine dalla pagina di rilascio di Kalliope https://github.com/kalliope-project/kalliope/releases (https://github.com/kalliope-project/kalliope/releases) e caricala come al solito su una scheda SD.
[b]Login[/b]: pi
[b]Password[/b]: raspberry
Una volta avviato, usare il comando raspi-config per espandere il file system e riempire lo spazio disponibile sulla scheda SD. Il server SSH è abilitato di default. Ottieni l'IP con il comando ip a e quindi connettiti tramite il tuo client SSH preferito.
Troverai alcune cartelle denominate "starter_kit_<language>" situate in /home/pi . Queste cartelle sono la configurazione di base che ti aiuterà a iniziare con Kalliope.
Installa tramite script
Basta eseguire il seguente comando bash per installare Kalliope su un Raspberry Pi:
bash -c "$ (curl -sL https://raw.githubusercontent.com/kalliope-project/kalliope/master/install/rpi_install_kalliope.sh)"
Installazione manuale
Nota: Si raccomanda di utilizzare un'installazione Lite di Raspbian senza alcuna interfaccia grafica per un'esperienza migliore.
Nota: Il primo Raspberry Pi non è ufficialmente supportato. L'installazione funzionerà ma un singolo core con soli 700Mhz questo potrebbe produrre latenza.
Ometto per ora.
Configurazione Raspberry Pi
Questa sezione tratta della configurazione necessaria per far funzionare kalliope su un RPi.
Configurazione del microfono
Ottieni info sull'output con:
aplay -l
Esempio di output con una cuffia USB collegata:
**** List of PLAYBACK Hardware Devices ****
card 0: ALSA [bcm2835 ALSA], device 0: bcm2835 ALSA [bcm2835 ALSA]
Subdevices: 7/8
Subdevice #0: subdevice #0
Subdevice #1: subdevice #1
Subdevice #2: subdevice #2
Subdevice #3: subdevice #3
Subdevice #4: subdevice #4
Subdevice #5: subdevice #5
Subdevice #6: subdevice #6
Subdevice #7: subdevice #7
card 0: ALSA [bcm2835 ALSA], device 1: bcm2835 ALSA [bcm2835 IEC958/HDMI]
Subdevices: 1/1
Subdevice #0: subdevice #0
card 1: Headset [Logitech USB Headset], device 0: USB Audio [USB Audio]
Subdevices: 0/1
Subdevice #0: subdevice #0
Qui vediamo che:
- l'audio analogico (dove è collegato il jack) è su card 0 e device 1
- l'audio USB è su card 1 e device 1
Ottenere info sull'input (microfono):
arecord -l
Esempio di output con una cuffia USB collegata:
**** List of CAPTURE Hardware Devices ****
card 1: Headset [Logitech USB Headset], device 0: USB Audio [USB Audio]
Subdevices: 0/1
Subdevice #0: subdevice #0
Qui vediamo una periferica su card 1 e device 0
Creiamo quindi un file di configurazione che applichi la seguente configurazione:
- uscita audio (voce di Kalliope) sull'audio analogico (tramite altoparlanti collegati al jack)
- input audio (ciò che viene detto a Kalliope) sul microfono USB
Creiamo un file in /home/pi/.asoundrc con il contenuto sottostante
pcm.!default {
type asym
playback.pcm {
type plug
slave.pcm "hw:0,0"
}
capture.pcm {
type plug
slave.pcm "hw:1,0"
}
}
Dove playback.pcm è l'audio in uscita e capture.pcm è l'audio in ingresso.
Riavvia ALSA per applicare le modifiche:
sudo /etc/init.d/alsa-utils restart
Regola la sensibilità del microfono eseguendo alsamixer:
[code]
alsamixer
Seleziona il microfono premendo F6 e regola il livello di sensibilità del mic :
(https://kalliope-project.github.io/kalliope/images/alsamixer_mic_level.png)
HDMI / Audio analogico
Per impostazione predefinita, se qualcosa è collegato a questa porta, il flusso audio utilizzerà HDMI . Controlla la documentazione ufficiale https://www.raspberrypi.org/documentation/configuration/audio-config.md per passare da HDMI ad analogico.
sudo raspi-config
Configura le tue impostazioni locales (lingua)
Le impostazioni locales definiscono impostazioni specifiche per lingua e paese per i tuoi programmi e la sessione di shell. Per impostare le impostazioni internazionali del sistema è necessario utilizzare la variabile di shell. Ad esempio, la variabile LANG può essere utilizzata per impostare la lingua it_IT (italiano).
Controlla le impostazioni locales in uso:
locale
Per aggiornare le impostazioni internazionali, digitare il comando seguente:
sudo dpkg-reconfigure locales
Seleziona nell'elenco il locales del tuo paese, selezionando il codice con UTF8, esempio:
- it_IT.utf8
- en_GB.utf8
- fr_FR.utf8
- es_ES.utf8
Quindi, aggiorna il tuo file /home/pi/.bashrc esportando la lingua. Esempio:
export LC_ALL = "en_US.UTF-8"
export LANG = "en_US.UTF-8"
export LANGUAGE = "en_US.UTF-8"
Esegui source per applicare le modifiche
source /home/pi/.bashrc
Testa il tuo marchingegno
Controlla il microfono e la configurazione degli speaker
Per assicurarti di poter registrare la tua voce, esegui il seguente comando per catturare l'input audio dal tuo microfono:
rec test.wav
Premi CTRL-C dopo aver catturato un campione della tua voce.
Quindi riproduci il file audio registrato
mplayer test.wav
La tua installazione è ora completa, diamo ora un'occhiata alla documentazione introduttiva https://kalliope-project.github.io/kalliope/getting-started/ per imparare come usare Kalliope.
(Optional) Avviare Kalliope automaticamente dopo un riavvio
Se si vuole avviare automaticamente Kalliope all'avvio poni il seguente script in /etc/systemd/system/kalliope.service.
Aggiorna il percorso <my_config_path> con il percorso in cui hai inserito i file brain.yml e settings.yml.
Aggiorna <username> con il nome di un utente non root. Ad esempio, su Raspbian puoi impostare pi.
[Unit]
Description=Kalliope
[Service]
WorkingDirectory=<my_config_path>
Environment='STDOUT=/var/log/kalliope.log'
Environment='STDERR=/var/log/kalliope.err.log'
ExecStart=/bin/bash -c "/usr/local/bin/kalliope start > ${STDOUT} 2> ${STDERR}"
User=<username>
[Install]
WantedBy=multi-user.target
E.g
[Unit]
Description=Kalliope
[Service]
WorkingDirectory=/home/pi/my_kalliope_config
Environment='STDOUT=/var/log/kalliope.log'
Environment='STDERR=/var/log/kalliope.err.log'
ExecStart=/bin/bash -c "/usr/local/bin/kalliope start > ${STDOUT} 2> ${STDERR}"
User=pi
[Install]
WantedBy=multi-user.target
Quindi, ricarica systemctl, avvia il servizio creato e abilitalo all'avvio
sudo systemctl daemon-reload
sudo systemctl start kalliope
sudo systemctl enable kalliope
Iniziare con Kalliope
Kalliope ha bisogno di due file per funzionare, un settings.yml e un brain.yml. Poiché i file sono scritti con sintassi YAML, ti consigliamo vivamente di utilizzare un editor (IDE) come VS Code o Atom.
Se stai usando kalliope da un Rpi, l'idea sarebbe quella di configurare il tuo assistente dal tuo computer con un IDE e poi inviare la configurazione al tuo RPI.
Quando avvii kalliope usando la CLI ( kalliope start ), il programma proverà a caricare settings.yml e brain.yml nel seguente ordine:
- Dalla tua cartella corrente, Eg /home/pi/my_kalliope/
- Da /etc/kalliope/
- Dal settings.yml e brain.yml di default che si trovano nel root del progetto Kalliope.
Questo è l'albero di default della cartella di configurazione di Kalliope:
kalliope_config/
├── brains
│ └── included_brain.yml
├── brain.yml
├── files
│ └── kalliope-EN-13samples.pmdl
└── settings.yml
Abbiamo creato uno starter kits che deve solo essere clonato, inserito nell'RPI e lanciato. Troverai l'intero elenco di start kits disponibili sul sito web di Kalliope https://kalliope-project.github.io/starter_kit.html. Questi repository forniscono una struttura per iniziare a imparare le basi di Kalliope. Scarica il kit di partenza a tua scelta e apri la cartella con il tuo IDE.
Tutti i file sono espressi in formato YAML (vedi Sintassi YAML https://learnxinyminutes.com/docs/yaml/ ) e hanno un minimo di sintassi, che tenta intenzionalmente di non essere un linguaggio o uno script di programmazione, ma piuttosto un modello di una configurazione o di un processo.
Apriamo il file principale dello starter kit Italiano. Vedrai che ci sono alcuni file di sub brains inclusi.
- includes:
- brains/say.yml
Se apri il file say.yml dalla cartella brains, vedrai una sinapsi di base che usa il neurone https://kalliope-project.github.io/kalliope/brain/brain/#neurons" Say " e fa parlare Kalliope ad alta voce "Ciao signore" quando dici "hello".
- name: "say-hello-it"
signals:
- order: "Hello"
neurons:
- say:
message: "Ciao signore"
Dividiamo il tutto in sezioni in modo che possiamo capire come viene costruito il file e cosa significa ogni parte.
I pezzi che iniziano con - sono considerati come elementi di questo elenco. I pezzi hanno il formato key: value il cui il valore può essere una semplice stringa o una sequenza di altri sotto elementi.
Al livello più alto abbiamo un tag "name". Questo è l'identificatore univoco della sinapsi. Deve essere univoca e accetta unicamente i caratteri alfanumerici e trattino. ([a - zA - Z0 - 9-])
- name: "Say-hello"
La prima parte, denominata signals, è una lista di azioni di input. Puoi aggiungere quante azioni vuoi nella sezione "signals". Se uno di questi viene attivato, la lista dei neuroni verrà eseguita.
signals:
- order: "say-hello"
Nell'esempio seguente, usiamo solo una azione, un "order", ma può anche essere:
- an order: Qualcosa che è stato pronunciato ad alta voce dall'utente.
- an event: Una data o una azione ripetuta (EG: ripetere ogni mattina alle 8:30)
- a mqtt message Un messaggio ricevuto su un argomento MQTT
- a geolocation Dalla posizione del tuo smartphone
- a community signal Ad esempio: Usando una GPIO consente di attivare azioni da un pulsante
- No signal. La sinapsi può essere chiamata solo da un'altra sinapsi o dall'API
Vediamo ora le dichiarazioni dei neurons. I neuroni sono moduli che verranno eseguiti quando l'azione di input (signal) viene attivata. È possibile definire quanti neuroni si desidera per la stessa azione di input (ad esempio: dire qualcosa, quindi fare qualcosa ecc ...). Questa contiene un elenco (perché inizia con un "-") di neurons
neurons:
- neuron_1_name
- neuron_2_name
- another_neuron
L'ordine di esecuzione dei neuroni è definito dall'ordine in cui sono elencati nella dichiarazione dei neurons.
Alcuni neuroni hanno bisogno di parametri che possono essere passati come argomenti seguendo la seguente sintassi:
neurons:
- neuron_name:
parameter1: "value1"
parameter2: "value2"
Nota che i parametri necessitano di una tabulazione sotto il nome del neurone (requisito di sintassi YAML).
In questo esempio, il neurone chiamato "say" farà sì che Kalliope pronunci ad alta voce la frase nel parametro message.
I neuroni possono essere Core (installati di default) o community based (devono essere installati).
È ora di avviare Kalliope. Spostati nella cartella e avvia Kalliope:
cd /path/to/the/starter_kit
kalliope start
Nota: Non avviare Kalliope come utente root o con sudo
Kalliope caricherà le settings e il brain, l'output dovrebbe apparire come segue
Starting event manager
Events loaded
Starting Kalliope
Press Ctrl+C for stopping
Starting REST API Listening port: 5000
Waiting for trigger detection
Ora pronuncia l'hotwork ad alta voce e vedrai che Kalliope (con la pronuncia corretta a seconda del tuo starter kit. "Kalliopé" in Francese, "Kalliopee" in Inglese, ecc.). Se pronunciato correttamente, vedrai "say something" nella console.
Say something!
Quindi potrai dire "hello" e ascoltare la risposta di Kalliope.
Say something!
Google Speech Recognition thinks you said hello
Order matched in the brain. Running synapse "say-hello"
Waiting for trigger detection
Questo è tutto! Sei pronto per personalizzare il tuo assistente!
Settings
settings.yml
Table of contents
Triggers configuration
default_trigger
triggers
Settings example
Available trigger engine
Players configuration
default_player
players
Settings example
Available players
Speech to text configuration
default_speech_to_text
speech_to_text
Settings example
Available STT
Text to speech configuration
default_text_to_speech
text_to_speech
cache_path
Settings example
Available TTS
Hooks
Settings example
Rest API
Resources directory
Global Variables
Options
energy_threshold
adjust_for_ambient_noise_second
send_anonymous_usage_stats
Questa parte della documentazione spiega la configurazione principale di Kalliope inserita nel file settings.yml .
Kalliope cercherà il file delle impostazioni nell'ordine seguente:
- Dalla cartella corrente, ad es. /home/pi/my_kalliope/settings.yml
- Da /etc/kalliope/settings.yml
- Di default cerca `settings.yml` nella cartella principale del progetto.
Configurazione dei trigger
default_trigger
Il trigger è l'engine che ha il compito di rilevare l'hotword che risveglierà Kalliope.
Alcune hotword comuni sono "Alexa" su Amazon Echo, "OK Google" su alcuni dispositivi Android e "Hey Siri" su iPhone.
Specificare il nome del modulo trigger che si desidera utilizzare.
default_trigger : "trigger_name"
Per esempio
default_trigger : "snowboy"
trigger
Il rilevatore di hotword (detto anche wake word o trigger word) è il motore che ha il compito di svegliare Kalliope.
Ogni trigger ha una propria configurazione. Questa configurazione è passata come argomento seguendo la seguente sintassi
trigger :
- trigger_name :
parameter_name : "valore"
Ad esempio, la configurazione predefinita di Snowboy è
trigger :
- Snowboy :
pmdl_file : "trigger/snowboy/resources/model.pmdl"
Esempio d'impostazioni
default_trigger : "snowboy"
trigger :
- Snowboy :
pmdl_file : "trigger / snowboy / resources / model.pmdl"
Trigger disponibili
| Doc | Note |
| ------------------------------ | ----------------------------------------------------- |
| [snowboy](triggers/snowboy.md) | Basato sul [software Snowboy](https://snowboy.kitt.ai/) |
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_player
Specificare il nome del modulo Players che si desidera utilizzare.
default_player : "player_name"
Per esempio
default_player : "mplayer"
players
Ogni 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 disponibili
I 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_text
Uno 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 disponibili
I 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_speech
Il 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_speech
Ogni 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_path
Gli 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'impostazioni
Esempio: 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/ (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 Cors
Se 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_threshold
Rappresenta 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_second
Se 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_stats
Questo 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/ (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 8)
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