Publié le 29 juillet 2017 - par

Kalliopé: un assistant personnel customisable

66 réponses

Kalliopé est un programme qui va vous permettre de concevoir vôtre propre assistant personnel vocal sur vôtre Raspberry Pi.

Kalliope un assistant vocal pour le Raspberry Pi

Présentation

Si vous voulez vous faire une idée de ce qu’il est possible de faire avec Kalliopé avant de poursuivre vôtre lecture, voici une petite vidéo de démonstration en français.

Le principe est simple :

  • vous choisissez un signal en entrée (par example un ordre vocal),
  • vous rattachez ce signal à une ou plusieurs actions (neurone) à exécuter

L’association entre un « signal » et une liste de “neurone” est appelée “synapse”. Les synapses sont placés dans le cerveau (brain) de Kalliopé.

Prenons un exemple de synapse simple que vous pourriez écrire :

Ici on décrit un synapse « hello-world », qui est exécuté sur un signal, de type « order » pour un ordre vocal,  et qui active le neurone de type “say”. Ce neurone permet de faire parler Kalliopé, il prend pour paramètre un message qui sera prononcé par le bot.

Au final, quand on dit « dis moi bonjour », Kalliopé vous répond « bonjour monsieur » .

Dans cet exemple, nous utilisons le neurone “say”, qui permet de faire parler le bot.

Il existe des neurones et des signaux pour toutes sortes d’utilisations. Par exemple, vous avez la possibilité de faire parler votre assistant, obtenir l’heure ou la météo, interagir avec une API, lancer un script ou même interconnecter vos synapses entre eux de façon à faire un dialogue.

Vous trouverez sur le site du projet une liste de neurones et de signaux que vous pouvez utiliser. Certains sont intégrés par défaut (core), d’autre sont communautaire et doivent être installés au préalable (community).

Vous pouvez également créer vos propres neurones ou signaux et les proposer à la communauté.

Le site propose aussi quelques exemples de vidéos par neurone ou signaux en plus de leur documentation respective.

L’installation

Petite note importante avant de vous lancer dans l’installation. Vous devez disposer d’un Raspberry Pi de deuxième ou troisième génération (Rpi 2 ou Rpi 3). Le Rpi 1 avec son CPU monocœur de 700 Mhz ne tient pas suffisamment la charge est n’est tout simplement pas supporté par le projet.

Si vous souhaitez installer le projet sur un Raspberry Pi, rien de plus simple. Vous trouverez une image de Raspbian pré-compilée sur la page Github du projet (dans le menu “release”).

Décompressez cette image et clonez-la sur votre carte SD comme vous le faite habituellement pour installer un Raspberry Pi.

Vous pouvez également suivre la procédure d’installation manuelle. Le projet support Ubuntu, Debian et Raspbian.

Testez que l’entrée et la sortie audio fonctionnent correctement. Pour cela, enregistrez vôtre voix:

Pressez CTRL-C pour stopper l’enregistrement, puis écoutez vôtre enregistrement avec la commande suivante.

Avec un micro-casque cela devrait fonctionner directement. Maintenant, si cela ne marche pas ou si vous souhaitez une configuration plus spécifique, comme par exemple la sortie audio sur le port jack et l’entrée sur le micro USB, suivez les instructions ci dessous.

On affiche nos périphériques de sortie

Ce qui donne une sortie comme celle-ci

Ici nous pouvons identifier que nous avons

  • une sortie analogique (ou le jack est connecté) sur la carte 0 et périphérique 0 (card0,  device0)
  • une sortie audio USB sur la carte 1 et périphérique 0 (card 1, device 0)

On affiche à présent les entrées audios

Ce qui donne une sortie du genre

Ici on voit que nous avons un micro USB  en carte 1 et périphérique 0 (card 1, device 0)

On va créer un fichier de configuration de façon à ce que :

  • la sortie audio (se que Kalliopé nous dit) soit sur la sorti analogique (le port jack)
  • l’entrée audio (se que l’on dit à Kalliopé) sur le micro USB

On créé donc un fichier /home/pi/.asoundrc avec le contenu suivant

Ici, playback.pcm est la sortie et capture.pcm est l’entrée.

On applique la configuration en redémarrant le service

Vous pouvez aussi ajuster le volume et la sensibilité du microphone avec la commande:

qui vous affichera un menu graphique. La touche F6 permettant de basculer d’un périphérique à l’autre.

Démarrage rapide

Kalliopé a besoin de deux fichiers pour fonctionner : settings.yml et brain.yml.

Pour bien débuter, vous pouvez cloner un kit de démarrage, qui vous donnera une configuration de base en français avec quelques exemples de synapses.

Si vous avez installé via l’image pré-compilée, le starter kit est déjà présent dans /home/pi.

Les fichiers de configuration utilisent la syntaxe YAML. Il est fortement recommandé d’utiliser un IDE comme VS Code ou Atom (tous deux gratuit) pour éditer ce type de fichier et détecter vos éventuelles fautes de syntaxe.

Une bonne pratique est de modifier via votre IDE les fichiers depuis votre poste de travail, puis de copier le dossier contenant toute la configuration sur votre raspberry. Pour cela vous pouvez utilisez WinSCP sur Windows ou Gigolo sur Linux.

Lancer Kalliopé

Une fois configuré, placez le dossier de configuration sur votre Raspberry. Placez-vous ensuite dans ce dossier et lancer le programme.

Une fois lancée, kalliopé sera en attente de la prononciation du “mot magique” qui permet de la réveiller.

Si vous avez cloné le kit de démarrage français, le mot magique est “kalliopé”. Prononcez-le, et l’état de Kalliopé devrait alors changer et attendre un ordre vocal de votre part.

Si vous avez lancé le kit de démarrage français, l’ordre “bonjour” est présent dans le brain. Vous pouvez prononcer à haute voix “bonjour” dans votre micro et Kalliopé vous répondra.

La configuration

Settings.yml: la configuration de Kalliopé

La configuration de kalliopé, qui se trouve dans le fichier settings.yml. La documentation complète se trouve ici.

Le trigger: moteur de réveil de Kalliopé

De la même manière que les produits commerciaux comme Alexa ou Google Assistant, Kalliopé possède un “mot-magique” aussi appelé “hot-word” afin de la réveiller.

Le hot-word est géré par un  programme en écoute permanente. Kalliopé supporte actuellement un seul moteur: Snowboy.

Vous pouvez changer le hot word en vous connectant au site Snowboy et en créant votre propre mot magique,  ou en améliorant un mot existant comme par exemple celui créé pour Kalliopé.

La création ou l’amélioration d’un hot-word génère un modèle sous la forme d’un fichier binaire. Une fois le modèle téléchargé, vous devez le placer dans le dossier de votre configuration et vous devez préciser le chemin vers ce dernier dans la configuration de Snowboy.

Ici, on précise que l’on va utiliser « snowboy » comme moteur de trigger, en regardant ensuite la documentation du trigger, on remarque que pour sa configuration, ce dernier requière le chemin vers un fichier pmdl. Ce fichier est en réalité le modèle du hotword. Ce modèle correspond à un mot en particulier. Si vous êtes sur le starter_kit français, le chemin pointe vers le modèle pour le mot « Kalliopé ». 

Vous pouvez créer vôtre propre hotword sur le site de snowboy, ou alors récupérer un model existant. Pour récupérer un modèle existant il vous faudra au préalable l’enrichir avec vôtre voix, puis télécharger le fichier pmdl correspondant à ce model pour le mettre dans la configuration de Kalliopé. Si vous souhaitez conserver le hotword « Kalliopé », je vous invite à aller améliorer le modèle sur le site.

Le player: le programme qui va gérer la sortie audio

Kalliopé propose de changer le programme qui gère la sortie audio. Par défaut la configuration est sur « mplayer ». Vous pouvez laissez ce réglage ou le modifier si vous le souhaitez. Le détail de configuration se trouve ici.

Speech to text: conversion audio→ texte

Kalliopé à besoin de transformer un ordre vocal en texte afin de l’analyser et d’exécuter les actions en fonction.

Par défaut, le moteur Speech To Text (STT) utilisé est celui de google, dans le cloud donc. Celui-ci propose d’excellent résultats. Cependant, pour les personnes soucieuses du respect de la vie privée, Kalliopé propose un moteur auto-hébergé et non connecté nommé CMUSphinx.

La liste des moteurs est disponible dans la documentation. Chacun de ces moteurs a sa propre configuration, les paramètres changent donc suivant celui que vous aurez choisi.

Pour google par exemple, en suivant sa documentation, sa seule configuration est le langage à utiliser.

Text to speech: conversion texte → audio

Dans l’autre sens, quand Kalliopé doit vous parler, son algorithme génère du texte qui faut convertir en audio. Il s’effectue au travers d’un moteur de Text To Speech (TTS).

Là aussi, Kalliopé propose plusieurs moteurs. Connectés ou non connectés. Pour certains, il est même possible de choisir la voix.

La syntaxe de configuration est toujours la même, on choisie le moteur que l’on va utiliser

Et on le configure

Par exemple, avec le moteur par défaut Pico2wav, qui est non connecté et offre un résultat très correct en français, la configuration sera la suivante:

Une fois encore, référez-vous à la documentation pour connaître la liste les moteurs disponibles, ainsi que le nom des paramètres à leur fournir pour leur bon fonctionnement.

Les Hooks

Les hooks permettent d’attacher des actions (synapses) en fonction du cycle de vie de Kalliopé. Il est par example utile de savoir que Kalliopé a bien détecté vôtre mot magique (hotword) et qu’elle est à présent en attente de vôtre ordre.

Pour utiliser les hooks, attachez le nom du hook au nom d’un synapse présent dans vôtre brain. 

Nom du hook Description
on_start Quand Kalliopé est démarée. Sera déclenché qu’une seule fois
on_waiting_for_trigger Quand Kalliopé attend la detection du mot magique
on_triggered Quand le mot magique a été detecté
on_start_listening Quand Kalliopé commence à écouter vôtre ordre
on_stop_listening Quand Kalliopé arrête d’écouter vôtre ordre
on_order_found Quand vôtre ordre a était trouvé dans le brain
on_order_not_found Quand vôtre ordre ne correspond à aucune entrée dans le brain
on_processed_synapses Une fois que tous les synapses ont étés exécuté
on_deaf Quand Kalliopé passe de l’état « en écoute » à l’état « en sourdine »
on_undeaf Quand Kalliopé passe de l’état « en sourdine » à l’état « en écoute »
on_mute Quand Kalliopé passe en mute (ne parle pas)
on_unmute Quand Kalliopé parle à nouveau
on_start_speaking Quand Kalliopé commencer à parler
on_stop_speaking Quand Kalliopé arrête de parler
on_stt_error Quand il y a un problème pendant la phase de capture de voix

Par example, vous voulez entendre une phrase aléatoire quand vous réveillez Kalliopé à l’aide de vôtre hotword.

settings.yml:

brain.yml:

Autre exemple, vous voulez savoir quand un ordre n’a pas été trouvé dans le brain

settings.yml:

brain.yml:

Vous pouvez par exemple allumer ou éteindre des LED sur vôtre raspberry en couplant les hooks on_start_speacking et on_stop_speacking avec un synapse qui utilise le neuron GPIO.

Les Variables globales

La variable « var_files » permet de spécifier un ou plusieurs fichiers contenant des variables qui peuvent être utilisées dans les paramètres de vos neurones.

Par exemple, je définis un fichier de variables dans mon fichier settings.yml comme ci-dessous :

Il faut bien sûr créer ce fichier à la racine du dossier de configuration. Et placer par exemple dans ce fichier une variable.

Je peux à présent utiliser cette variable dans mes synapses. Pour cela j’utilise une double parenthèse afin de faire comprendre au moteur qu’il s’agit d’une variable.

Ces variables seront très pratiques pour réutiliser un même paramètre. Par exemple, si vous avez plusieurs synapses utilisant le neurone URI (qui permet de faire des appels à un service web), vous pouvez spécifier l’adresse de l’URL dans une variable et utiliser cette dernière dans vos synapses. Ainsi, si l’URL change, vous aurez besoin de changer l’adresse qu’a un seul endroit.

brain.yml: le cerveau de Kalliopé

On va à présent faire un tour sur la partie la plus importante de Kalliopé: son cerveau.

Comme expliqué plus haut, le cerveau (brain) de kalliopé est composé de synapses. Un synapse est l’association d’un signal avec une liste de neurones.

Les signaux

Il existe plusieurs type de signaux. Nous allons en décrire ici 2 couramment utilisés:

  • Un ordre (order)
  • un événement planifié (event)  

Il existe d’autres type de signaux comme le GPIO input qui peut vous permettre de déclencher vos actions suivant un changement d’état d’un port GPIO du RPI. Pour la liste des signaux disponible c’est par là.

Les ordres

Un ordre est une phrase capturée par le microphone et envoyé au moteur STT afin d’être analysé.

Voici un ordre simple:

Nous allons voir maintenant un ordre avec argument. Les arguments sont important pour améliorer la flexibilité de votre bot.

Prenons un exemple avec le neuron Wikipédia qui, bien-sur, permet d’effectuer une recherche sur Wikipédia.

Nous pouvons créer un synapse avec un ordre simple comme ceci

Le synapse va fonctionner, mais cela revient à coder en dur chaque recherche que l’on voudrait effectuer. Pas franchement top pour impressionner les amis. C’est là qu’interviennent les arguments.

Modifions notre synapse

On ajoute un argument à l’ordre. Kalliopé va donc insérer tout ce qui est dit après la phrase « cherche sur wikipédia » dans une variable nommée « ma_recherche ».

Cette variable est ensuite utilisable dans les paramètres des neurones. Ici je le donne au paramètre « query », qui est le nom de la page recherchée.

Les events

Le second type de signal est l’événement planifié (event).

Ce type de signal permet de planifier un événement suivant une fréquence. Par exemple, je veux que Kalliopé me dise bonjour tous les matins à 7h30 en semaine, qu’elle me donne l’heure et me lance ma web radio préférée. Je vais créer un synapse comme celui ci:

La liste complète des paramètres utilisables par un event sont dans la documentation.

Les neurones

Le dernier point, les neurones. Un neurone est un module, ou plugin, qui va effectuer une action.

Syntaxe

Vous pouvez définir autant de neuron que nécessaire dans un seul synapse sous forme de liste.

La syntaxe est la suivante:

Paramètres en entrée

Un neuron demande parfois des paramètres en entrée pour fonctionner. Nous trouverez la liste des paramètres dans la documentation du neurone. Certains sont obligatoires, d’autres optionnels.

Un paramètre peut être donné directement dans la configuration du synapse en dur comme ici

Ici, les paramètres « bridge_ip », « group_name » et « state » sont codés en dur dans le synapse.

Un paramètre peut être récupéré depuis l’ordre comme ceci:

Ou alors récupéré depuis une variable globale comme cela:

Note importante: Si vous utilisez une variable dans un paramètre, il est obligatoire d’utilisez les doubles guillemets pour encadrer celui-ci.

Cette syntaxe est fausse:

Celle-ci est correct:

Paramètres en sortie

Kalliopé est un framework, cela signifie que c’est un outil pour concevoir votre assistant comme vous le souhaitez.

Chaque neuron possède sa propre configuration en entrée, et retourne des variables en sortie que vous pouvez utiliser pour concevoir votre réponse.

Prenons un exemple avec le neurone « systemdate », qui permet de donner l’heure. La documentation de ce neurone vous donne la liste des variables qui seront retournées et que vous pouvez utiliser dans votre template.

Les variables instanciées qui serons retournées sont: hours, minutes, weekday, month, day_month et year.

On peut donc écrire un synapse avec un template de réponse comme suit:

Ici, Kalliopé instanciera les valeurs « hours » et « minutes » au moment de l’appel et les transmettra au template « say_template ».

Ce qui donnera un résultat du genre: « il est 9 heures et 32 minutes ».

Vous pouvez donc choisir ce que va répondre vôtre bot, et ce dans la langue que vous souhaitez du moment que le moteur TTS gère cette langue.

Le templating est basé sur un moteur nommé Jinja. Ce moteur vous permet de jouer avec les variables comme bon vous semble.

Par exemple, je modifie mon synapse pour que cette fois il utilise un fichier de template.

Je créé à présent un fichier gouter.j2 avec le contenu suivant

J’utilise ici le moteur et sa structure de contrôle afin de faire dire à mon bot si il est l’heure du goûter en fonction des variables retournées par le neurones au moment de l’utilisation.

Jinja propose de multiples structures de contrôles (if, else, boucle for, etc..) vous permettant de créer un nombre illimité de combinaison pour les réponses de vôtre assistant.

Mise en mémoire de variable avec Kalliope Memory

Kalliopé peut stocker en mémoire à court terme:

  • des paramètres de sortie des neurones
  • des variables provenant d’un ordre

Exemple 1: mise en mémoire de paramètres de sortie d’un neuron. 

Ici, le neuron systemdate génère des variables qui sont données en sortie au template pour faire parler kalliopé et également passés à la mémoire temporaire de Kalliopé.

La mémoire peut être utilisée dans un autre appel d’un autre synapse comme ceci

Etant basé sur un système de Template, la valeur peut être modifié en ajoutant d’autres mots  au moment de la mise en mémoire:

Ou concaténer plusieurs variables de sortie du neuron dans la même variables en mémoire:

Exemple 2: mise en mémoire de paramètres capturés dans l’ordre

Ici, la variable « name »  est utilisée dans le template au moment de faire parler Kalliopé et est également placée en mémoire sous une variable nommée « friend ».

On peut par la suite accéder à la mémoire pour faire répéter le nom de nôtre ami

Un dernier exemple pour comprendre la mécanique de mémoire de Kalliopé. Dans le scénario suivant, on veut que Kalliopé nous rappelle d’appeler nôtre maman dans 15 minutes

  • Moi: rappel moi de téléphoner à maman dans 15 minutes
  • Kalliopé: Je vous le rappel dans 15 minutes
  • 15 minutes plus tard…
  • Kalliopé: Vous m’avez demandé de vous rappeler de téléphoner à maman il y a 15 minutes

Voici le brain que l’on peut écrire

Quelques bonnes pratiques

Enchaîner les ordres

Le comportement normal de Kalliopé est de faire appel au hotword entre chaque ordre de façon à réveiller Kalliopé. (Kalliopé!, Oui? Fais ci, Kalliopé!, Oui? Fais ça, etc…)

Depuis la version 0.5.1, il est possible d’envoyer une notification aux signaux pour modifier leur comportement. Ceci s’effectue grace au neurone « Signals« .

Le signal de type « order » peut être modifié à la volé grace à ce neuron. Le signal est à l’écoute d’une notification de type « skip_trigger« . Si le skip_trigger est activé, Kalliopé va alors se mettre à nouveau en état d’écoute d’un nouvel ordre à la fin de l’exécution de l’ordre précédant jusqu’à ce que le skip_trigger soit de nouveau désactivé.

Pour mettre en place ce système, on commence par ajouter un synapse à notre hook « on_triggered » comme ceci

A chaque fois que l’on va réveiller Kalliopé ave le trigger, le synapse « start-skip-trigger » sera appelé. On va créer ce synapse dans le brain.yml

Et voilà! Maintenant Kalliopé va indéfiniment attendre un nouvel ordre à chaque fin d’execution de synapses. Du coup, on vient de créer un boucle infini. Il nous faut un nouvel ordre pour mettre fin à cette boucle. On ajoute un nouveau synapse dans le brain.yml

Cette fois c’est bon, on peut à présent enchaîner les ordres. Il faudra bien penser à remercier Kalliopé à la fin quand on a plus besoin d’elle de façon à la remettre en état d’attente du mot magique via le trigger.

Infos et liens utiles

Ce petit article est une introduction au projet et ne couvre pas l’ensemble des possibilités du programme. Si vous voulez en savoir plus, Kalliopé propose:

Sources

Share Button

66 réflexions au sujet de « Kalliopé: un assistant personnel customisable »

  1. Pascal

    Excellent projet 🙂
    Ca rassemble au projet Sarah ( https://blog.encausse.net/s-a-r-a-h ) mais sur un Raspberry!
    Ce qui est important avec ces assistants, c’est qu’on n’envoie pas nos requêtes sur un serveur distant, donc elles restent confidentielles..
    Pour finir mon commentaire, j’ajoute mon expérience perso avec Sarah: le meilleur résultat est avec le micro de la console kinect qui existe en USB, mais il faut passer par un HUB car le raspberry ne délivre pas assez d’ampères. Pour + d’info sur son installation sous linux pour ceux que ça intéresse: cherchez kinect-audio-setup sur google 🙂

    Répondre ↓
  2. gUI

    Génial ! Je me demandais récemment si un équivalent DIY existait. Merci pour ce tuto très complet.

    Je m’interroge toutefois sur le micro. Comment faire pour avoir un micro accessible « de partout » ? J’ai cru comprendre que les assistants type Amazon ou Google utilisaient 5 ou 6 micros… Quelqu’un a déjà essayé la reconnaissance vocale dans le salon ?

    Répondre ↓
    1. nico69400

      Déjà testé avec S.A.R.A.H et un kinect V1 et la reconnaissance et vraiment bonne.
      La solution avec la pi serait d’utiliser le « stereo microphone Voice HAT board » fourni avec le magpi 57 pour une meilleur reconnaissance vocal. Je vais tester Kalliopé avec cette technique prochainement. Couplé à domoticz et IFTTT ça devrait être top

      Répondre ↓
  3. Nicolas Marcq Auteur de l’article

    Effectivement le Google AIY kit semble parfait. Mais je n’ai pas pu le tester.

    Voici une liste de lien pour des micros qui peuvent convenir
    – Google AIY kit: https://aiyprojects.withgoogle.com/voice#project-overview
    – ReSpeaker: https://www.seeedstudio.com/ReSpeaker-Mic-Array-Far-field-w%2F-7-PDM-Microphones-p-2719.html?gclid=CjwKEAjwjPXIBRDhwICRg-DbgHISJADP6QXpXKwXtUAWSUXOEHYBFvXmOmVpbQzR3tz7kh9TlV0TUxoC7Hnw_wcB
    – CM1000: https://www.amazon.com/dp/B008BS3CF8/ref=cm_sw_su_dp
    – matrix voice: http://www.01net.com/actualites/matrix-voice-l-alternative-open-source-a-amazon-alexa-qui-s-appuie-sur-un-raspberry-pi-1133300.html

    Répondre ↓
  4. gUI

    Merci à toi et à nico69400 pour ces pistes. Le ReSpeaker m’intéresse bien, mais c’est vrai qu’un kinnect d’occase de vide grenier doit être pas mal pour tester 🙂

    Répondre ↓
  5. nico69400

    Pas donné le ReSpeaker. Mais semble être une bonne solution pour une meilleur intégration.
    L’avantage du Kinect c’est que je peux aussi l’utiliser en tant que scanner pour l’impression 3D. 2 en 1 pour plus très cher en occas’ (une 20aines d’euros il y a 3 ans).

    Répondre ↓
  6. Morreale

    Bonjour, quelle solution d’assistant diy sur rpi est elle la plus aboutie à l’heure actuelle? Kalliopé ou glady?
    Sont elles comparable d’ailleurs? Quelles sont leurs différences?

    Répondre ↓
    1. Nicolas Marcq Auteur de l’article

      Kalliopé est beaucoup plus jeune. Donc probablement moins aboutie que Gladys. Mais l’approche n’est pas la même alors je ne sais pas si on peut comparer.
      Je pense que dans le cadre d’une installation domotique il faut tout simplement tester plusieurs solutions et prendre celle qui correspond à ses attentes. Kalliopé fonctionne uniquement avec un système de configuration en YAML qui peut rebuter les non initiés au premier abord.

      Répondre ↓
  7. Denis

    Bonjour tout le monde.

    l’installation s’est passé à merveille.

    pour autant je n’arrive pas à changer les wake word answer dans le fichier settings.yml

    en effet j’arrive bien à les modifier,supprimer ou en ajouter mais kalliopé ne les prends pas en compte

    quelqu’un aurait il une piste s’il vous plait

    Merci beaucoup
    Denis

    Répondre ↓
  8. nvg269

    Bonjour ! Merci pour le tuto… J’ai une question ? Pour interagir avec Kalliope il faut dire son nom (Kalliope) est-ce qu’il y a moyen de changer ça ? Genre dire Sarah ou peu importe le nom qu’on veut lui donner ?

    Merci !

    Répondre ↓
  9. miguipda

    Bonjour,

    kalliopé fonctionne-t-il offline ou doit-il impérativement rester connecté à internet ?

    Kalliopé fonctionne-t-il avec pulseaudio en vue de pouvoir contacter spécifiquement une personne connectée à son réseau (utilisant ainsi le micro et haut-parleur de l’ordinateur ou laptop connecté) ?

    Merci.

    Répondre ↓
      1. miguipda

        Merci de votre réponse.
        Deux objectifs à cet aspect offline :
        1) sécurité et/ou coupure d’internet
        2) réduction de consummation data sur un abonnement internet 4G

        De ce fait, est-il possible de lancer l’appel au neurons dans une tranche horaire ou après avoir ouvert l’accès vers internet (pour ensuite le couper) ? Cela permettrait de disposer des infos utiles au réveil et de ne les rouvrir qu’en rentrant le soir.
        Permettant alors de garder le max de ressources pour la video surveillance (motion) lors de l’absence à la maison.

        3) quid de l’utilisation audio pulseaudio ? Une envie de pousser plus loin le multi-rooming ou ciblage de client qui fait appel (via son ordinateur ou laptop) à kalliopé ?! 😉

        Excellente journée.

        Répondre ↓
        1. Nicolas Marcq Auteur de l’article

          L’appel aux neurones c’est vous qui l’effectuez. Et donc dans la tranche horaire que vous souhaitez.
          Il n’y a pour le moment pas de documentation pour une utilisation multi-rooming via pulse audio. C’est cependant réalisable. A savoir aussi que Kalliopé va implémenter dans le future un mode client serveur avec la possibilité de mettre des Rpi clients dans les pieces qui parleraient à un Rpi serveur pour le traitement.

          Répondre ↓
          1. miguipda

            Je comprends l’orientation client/serveur, mais à mon sens Kalliopé est le serveur. Les clients sont alors les périphériques usuels : ordinateur, laptop, tablette, smartphone, haut-parleur bluetooth, casque-micro bluetooth, …

            D’où les besoins pulseaudio pour les dédiés ordinateurs/laptop/tablette/smartphone (si ça existe pur ces deux derniers) et bluetooth pour lesdits haut-parleurs (que le sont tablette/smartphone/haut-parleurs portatifs, casque, …)

            Répondre ↓
  10. nvg269

    Salut ! J’ai une autre question ? J’ai tout installé et tout semble ok… Quand je dis « Kalliope » je vois qu’elle me répond à l’écran mais je l’entends pas par-contre… Je suis en HDMI sur ma TV et j’entends rien de sa part du coté audio… pourquoi ? Avez-vous une idée du problème ?

    Merci beaucoup !

    Répondre ↓
  11. philippe

    Bonjour,
    très beau projet avec un potentiel énorme.
    Sur les vidéos de présentation et d’exemples de neurons c’est très réactif, d’où ma question :
    Pour les vidéos, Kalliope est sur un pc ou un raspberry et avec quelle marque de micro ?

    merci

    Répondre ↓
    1. Nicolas Marcq Auteur de l’article

      Pour les vidéos c’est souvent depuis un PC avec une VM Ubuntu. Mais la réactivité est la même sur un Rpi.
      Et pour le micro cela dépend. Dans le cadre des tests on en a utilisé plusieurs. Le plus souvent des micro casques. L’idée étant bien sur de prendre un micro de type « pieuvre » comme un ReSpeacker pour une mise en prod.

      Répondre ↓
      1. philippe

        Merci pour cette réponse très rapide, il me reste plus qu’a faire des tests depuis un pc ou un rpi3.
        Pour le moment j’ai fais des test avec un Rpi2, c’est pas très réactif mais je pense que les micros utilisés y sont pour beaucoup (faut que je fasse un essai avec la kinect 360 si j’arrive a faire fonctionner son micro avec le Rpi).

        Répondre ↓
  12. AMaX

    Faire mumuse avec ces assistants me démange depuis longtemps, mais avoir un micro connecté me donne des nausées… Si c’est local et personnalisable par contre, c’est plus du tout pareil. Je me commande un Pi de plus, sur-le-champ… ^^

    Merci beaucoup pour cette découverte !

    Répondre ↓
  13. Goj34

    Bonjour et félicitation pour ce projet!
    Je suis en train de le tester avec une image sur un Raspberry. Cependant quand je veux démarrer Kalliope j’ai un message d’erreur:
    « pi@kalliope:~ $ kalliope –version
    Traceback (most recent call last):
    File « /usr/local/bin/kalliope », line 6, in
    from pkg_resources import load_entry_point
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 3036, in
    @_call_aside
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 3020, in _call_aside
    f(*args, **kwargs)
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 3049, in _initialize_master_working_set
    working_set = WorkingSet._build_master()
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 656, in _build_master
    return cls._build_from_requirements(__requires__)
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 669, in _build_from_requirements
    dists = ws.resolve(reqs, Environment())
    File « /usr/local/lib/python2.7/dist-packages/pkg_resources/__init__.py », line 854, in resolve
    raise DistributionNotFound(req, requirers)
    pkg_resources.DistributionNotFound: The ‘pyalsaaudio>=0.8.4’ distribution was not found and is required by kalliope
     »
    J’ai vérifié la dépendance avec pip install pyalsaaudio et cela m’indique que le version est bien installée.
    Merci pour votre aide.
    Goj

    Répondre ↓
      1. Goj34

        J’ai installé l’image toute prête. C’est pour cela que ça m’étonne.

        pour la commande:
        pi@kalliope:/usr/local/lib/python2.7/dist-packages/pkg_resources $ sudo pip install pyalsaaudio
        Requirement already satisfied: pyalsaaudio in /usr/local/lib/python2.7/dist-packages/pyalsaaudio-0.8.4-py2.7-linux-armv7l.egg

        merci pour tes réponses.

        Répondre ↓
        1. Goj34

          j’ai installé pyalsaaudio avec les sources et je n’ai plus le message mais j’en ai un autre maintenant. Comme si les dépendances n’avaient pas été installées malgré l’image injectée sur la carte SD…
          Je refais ma carte SD avec une nouvelle image fraichement télécharger. On verra bien.

          Goj34

          Répondre ↓
        1. Nicolas Marcq Auteur de l’article

          étrange. Vous pouvez sinon simplement suivre la procédure d’installation manuelle par dessus l’installation. Cela installera les dépendances manquante. Je vais refaire une installation fraîche depuis l’image pour la vérifier de mon coté.

          Répondre ↓
  14. nvg269

    Salut ! J’ai une autre question… J’ai réinstallé Kalliope aujourd’hui car l’autre fois j’avais un problème de son (J’entendais pas Kalliope répondre)

    J’ai fais cette commande qui viens du site de la documentation raspberrypi.org
    amixer cset numid=3 2
    sudo raspi-config et j’ai mis sur HMDI

    et ensuite j’ai fais ça : In some rare cases, it is necessary to edit config.txt to force HDMI mode (as opposed to DVI mode, which does not send sound). You can do this by editing /boot/config.txt and setting hdmi_drive=2, then rebooting for the change to take effect.

    Je suis entrain de me demander si la cause de mon problème est que sa viendrais peux-être de la synthèse vocale dans mes configs. Kalliope répond bien à ma question quand je lui demande « Quelle heure est-il » je le vois dans mais aucun son… Quelqu’un aurais une idée ? Car je suis vraiment bloqué…

    Répondre ↓
    1. nvg269

      J’ai fais un test en enregistrant ma voix avec la commande suivante:

      rec test.wav et ensuite j’ai testé mplayer test.wav et j’entends rien…

      J’ai testé ce que j’ai enregistré (test.wav) sur mon ordi et j’entends bien ma voix.

      Répondre ↓
      1. nvg269

        Bon ! En fin compte j’ai du son… J’ai mis mon casque d’écoute et j’entends Kalliope me répondre. Mais c’est vraiment pas fort. Donc c’est clair que j’entends rien sur speaker.

        Quelqu’un aurait une solution ?

        Merci !

        Répondre ↓
  16. fab

    je vous invite a regarder « alexylem » un projet que je suis depuis les debut et qui vous suprendra tous 😉
    avec un mode offline et le choix de son stt et tts et appli android/web

    Répondre ↓
  17. cyril

    Bonsoir,

    Cela fait quelques jours que j’essaye d’installer Kalliope (après avoir testé Jarvis) et je bloque à l’installation. J’ai cette erreur après installation 1 en manuelle

    Command « python setup.py egg_info » failed with error code 1 in /tmp/pip-build-EOEBLm/cryptography/

    Je passe du temps sur les forums et internet mais rien ne résout le pb. Au cas où vous auriez une idée.
    Merci

    Répondre ↓
  18. cyril

    et quand je teste d’autres configurations manuelles j’ai ceci :

    kalliope start
    Traceback (most recent call last):
    File « /usr/local/bin/kalliope », line 5, in
    from pkg_resources import load_entry_point
    File « /usr/lib/python2.7/dist-packages/pkg_resources.py », line 2876, in
    working_set = WorkingSet._build_master()
    File « /usr/lib/python2.7/dist-packages/pkg_resources.py », line 449, in _build_master
    ws.require(__requires__)
    File « /usr/lib/python2.7/dist-packages/pkg_resources.py », line 745, in require
    needed = self.resolve(parse_requirements(requirements))
    File « /usr/lib/python2.7/dist-packages/pkg_resources.py », line 639, in resolve
    raise DistributionNotFound(req)
    pkg_resources.DistributionNotFound: mock>=2.0.0

    Merci

    Répondre ↓
  19. miguipda

    @Nicolas Marcq,

    bonjour,

    je viens de « retomber » sur Kalliopé et je pense que je vais tabler d’avantage dessus pour autant que je puisse disposer de réponse sur les sujets suivants :
    1) pour autant que ce soit possible, comment changer le KWS (KeyWord Spotting – mot clé déclencheur) de Kalliopé à un nom plus personnel ?

    2) TTS : est-ce que SVOX Pico est inclus d’office dans Kalliope sinon quels paramètres doivent être mentionnés pour être parfaitement fonctionnel. Au vu des possibilités de langue parlée natif sur Android et Linux : https://ankiatts.appspot.com/services/pico2wave), et comme il est fonctionnel hors ligne (self-hosted) c’est une nécessité basique, svp : https://svoxmobilevoices.wordpress.com/demos/ (si c’est bien ce SVOX là qui est ledit SVOX Pico)

    3) TTS : intégrer également MARY TTS serait une bonne chose également pour sa fonctionnalité de fonctionnement hors ligne (self-hosted) : http://mary.dfki.de/

    4) STT : est-ce que SnowBoy est également intégré d’office dans Kalliope ? Sinon idem, comment paramétrer correctement (exemples) celui-ci pour l’y intégrer ?

    5) Un point qui n’apparaît pas clairement dans les explications de Kalliope (à moins que je n’ai raté ces explications) : est-ce que Kalliope est bien constamment en mode veille, c’est à dire qu’elle n’écoute pas constamment tout ce qu’on dit, et qu’elle n’écoute alors que lorsqu’on la réveilel par l’appel de son nom ?

    D’avance merci pour chaque réponse fournie à ces questions précises.

    Excellente journée et au plaisir de vivre avec Kalliope 😉

    Miguipda

    Répondre ↓
    1. Nicolas Marcq Auteur de l’article

      1- oui on peut changer le hotword. Il est basé sur snowboy. La doc ici
      2- Pico est de façon native et par défaut dans kalliopé. Voir la liste des TTS et la doc ici
      3- Mary TTS est pour bientôt
      4- Snowboy est utilisé uniquement pour le hotword. pour l’odre ensuite c’est le moteur de STT qui prend la main
      5- kalliopé est en écoute permanente dans le cadre de la detection du hotword par Snowboy. Ce processus est totalement offline et self hosted par snowboy

      En espérant avoir répondu à tes questions.

      Répondre ↓
  20. georges

    Bonjour,
    Je vous félicite pour ce projet.
    Je vais être clair au départ. Je ne connais rien en intelligence artificielle pour le moment. Ce que je peux dire c’est que j’ai dejà fait un projet domotique avec Arduino(La sécurisation d’une porte d’entrée avec la possibilité d’ouvrir la porte à distance).
    Je me pose une question, si je dois pouvoir réaliser un projet domotique comme le viotre qui prendra en charge Kalliopé, qu’est-ce que vous me conseillé comme prérequis afin de bien installer kalliopé ?

    Répondre ↓
      1. georges

        Merci Nicolas Marcq, vous êtes prompt.
        Comment vous suivre via les réseaux sociaux ?
        J’aimerais bien m’inspirer de vous si cela ne vous dérange pas.

        Répondre ↓
    1. Pierre tremi

      Bonjour Nicolas, je voudrais vous demander ceci, pour la démonstration que vous avez pu faire avec kalliopé sur Youtube, la partie automatisation est faite par une carte arduino ? Laquelle par exemple?

      Répondre ↓
  22. Moulis

    Bonjour,
    J’ai fabriqué un système domotique sur la base d’un STM32F4.
    Maintenant, j’aimerai le faire interagir avec un assistant vocal et Kalliopé me semble très bien.
    Par contre je me suis laissé entendre dire que le service de reconnaissance vocale de Google serait payant. est-ce vrais? car celui de Bing l’est…
    Merci pour votre réponse
    Raphaël

    Répondre ↓
    1. Nicolas Marcq Auteur de l’article

      Google passe payant après un certain nombre de requêtes mensuelle. Sinon il est gratuit et marche plutôt bien. Kalliope propose d’autres STT si Google (par défaut) ne convient pas.

      Répondre ↓
  23. Moulis

    bonjour,
    Très bien, je viens de l’installer et les débuts sont prometteur. merci.

    Par contre j’ai un soucis avec la recherche wikipédia: lors du démarrage il me génère une erreur d’importation. il ne trouve pas le module wikipedia .
    J’ai fait une impression écran. pourriez-vous m’indiquer comment vous la transmettre.

    l’erreur est dans le fichier wikipedia_searcher.py » ligne 4 in
    import wikipedia
    Import error: no module named wikipedia

    Merci
    raphael

    Répondre ↓
  24. Moulis

    Bonjour,
    Merci, désolé, c’était aussi simple que çà! Je suis un néophyte en système à base d’UNIX. je suis plus dans l’électronique et les langages de programmation type assembleur ou C.
    Sinon, tout fonctionne très bien. un peu trop même: il lui arrive très fréquemment de s’activer lors de nos conversations banales, sans même que nous ayons prononcé le mot « magique » (personnalisé).
    Auriez-vous un réglage permettant d’être moins sensible?
    merci
    Raphael

    Répondre ↓
      1. Moulis

        Merci bien je vais essayer.
        Concernant le hotword, j’ai déjà crée le mien et c’est avec lui que j’ai des soucis. Je pense qu’il est un un peu trop simple. Je n’ai pas trop essayé avec kalliopé.
        Une idée pour un agenda intégré (pas google)? je n’en ai pas vu. je l’ai peut-être loupé.
        Et pour effacer seulement une ligne d’une TODOLIST avec une commande vocale ou l’envoyer par mail?
        Merci pour votre réactivité. votre système est très passionnant.

        Répondre ↓
  25. Moulis

    bonsoir,
    Encore un soucis:
    J’ai installé google calendar:
    – installation avec la ligne de commande dans GITHUB:
    kalliope install –git-url https://github.com/bacardi55/kalliope-google-calendar.git
    ->RAS
    – inscription et récupération des fichiers (credential et secret) auprès de Google:
    ->RAS
    -mise en place du neurone et du template.
    ->RAS
    et voici l’erreur:
    Google Speech Recognition thinks you said quels sont mes prochains rendez-vous
    Order matched in the brain. Running synapse « Google-agenda-next »
    Exception in thread :
    Traceback (most recent call last):
    File « /usr/lib/python2.7/threading.py », line 801, in __bootstrap_inner
    self.run()
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/signals/order/order.py », line 87, in run
    self.start_trigger()
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 383, in trigger
    return self.machine._process(func)
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 1059, in _process
    self._transition_queue[0]()
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 399, in _trigger
    return self._process(event_data)
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 409, in _process
    if trans.execute(event_data):
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 263, in execute
    self._change_state(event_data)
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 274, in _change_state
    event_data.machine.get_state(self.dest).enter(event_data)
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 120, in enter
    event_data.machine.callback(handle, event_data)
    File « /usr/local/lib/python2.7/dist-packages/transitions-0.6.8-py2.7.egg/transitions/core.py », line 1005, in callback
    func(*event_data.args, **event_data.kwargs)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/signals/order/order.py », line 185, in analysing_order_thread
    is_api_call=False)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/SynapseLauncher.py », line 104, in run_matching_synapse_from_order
    execdata = lifo_buffer.execute(is_api_call=is_api_call)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/Lifo/LIFOBuffer.py », line 109, in execute
    self._process_synapse_list(last_synapse_fifo_list)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/Lifo/LIFOBuffer.py », line 139, in _process_synapse_list
    self._process_neuron_list(matched_synapse=matched_synapse)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/Lifo/LIFOBuffer.py », line 173, in _process_neuron_list
    parameters_dict=matched_synapse.parameters)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/NeuronLauncher.py », line 62, in start_neuron
    instantiated_neuron = NeuronLauncher.launch_neuron(neuron)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/NeuronLauncher.py », line 44, in launch_neuron
    resources_dir=neuron_folder)
    File « /usr/local/lib/python2.7/dist-packages/kalliope-0.5.2-py2.7.egg/kalliope/core/Utils/Utils.py », line 140, in get_dynamic_class_instantiation
    return klass(**parameters)
    File « /home/pi/kalliope_starter_fr/resources/neurons/google_calendar/google_calendar.py », line 52, in __init__
    credentials = self.get_credentials()
    File « /home/pi/kalliope_starter_fr/resources/neurons/google_calendar/google_calendar.py », line 116, in get_credentials
    credentials = store.get()
    File « /usr/local/lib/python2.7/dist-packages/oauth2client/client.py », line 407, in get
    return self.locked_get()
    File « /usr/local/lib/python2.7/dist-packages/oauth2client/file.py », line 54, in locked_get
    credentials = client.Credentials.new_from_json(content)
    File « /usr/local/lib/python2.7/dist-packages/oauth2client/client.py », line 302, in new_from_json
    module_name = data[‘_module’]
    KeyError: ‘_module’

    J’ai encore due louper quelque chose.
    J’ai même installé: pip install –upgrade google-api-python-client oauth2client

    Même problème.
    Une solution?
    De ce que je comprend il recherche un module qu’il ne connait pas.
    Merci pour votre aide.
    Raphael

    Répondre ↓
    1. Nicolas Marcq Auteur de l’article

      Il y a un chat en lien dans l’article pour le support de kalliope. Plus pratique que les commentaires dans ce blog. Et sinon pour les problèmes liés à un neurone en particulier vous pouvez ouvrir un ticket GitHub sur le repo du neuron en question.

      Répondre ↓

  27. Ping : Miroir Magique ! – L'Atelier Made In iKi

  28. Leoxx420

    Bonjour, je suis novice et je ne comprend pas comment faire et ou aller exactement pour entrer les ordres qu’on veut donner à Kalliope,
    J’ai essayé avec l’exemple de Batman mais il me dit qu’il ne comprend pas cet ordre, serait-il possible de m’expliquer plus simplement svp?

    Répondre ↓

  29. Ping : Piclodio: transformez votre Raspberry en web radio réveil - Framboise 314, le Raspberry Pi à la sauce française....

  30. Ping : Un Miroir Magique (Magic Mirror) avec le Raspberry Pi - Framboise 314, le Raspberry Pi à la sauce française....

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Complétez ce captcha SVP *

Ce site utilise Akismet pour réduire les indésirables. En savoir plus sur comment les données de vos commentaires sont utilisées.