PAGE WIKI ETUDIANTS 2011-12 SERRURE VOCALE

=Cahier des charges=

Présentation Générale du problème
Le but de ce projet est de développer un système de reconnaissance vocale.

Projet
Le projet consiste à réaliser un programme permettant d'ouvrir une gâche électronique simplement par la parole. Les voix des locuteurs seront préalablement enregistrées, et devront être identifiées par un système de reconnaissance vocale afin de permettre ou non l'ouverture de la gâche électronique.

Contexte
Nous avons également effectué une étude de l’existant, ce projet ayant été réalisé l’an passé par un groupe de 12 personnes:

Ce projet est essentiellement composé de trois grandes parties:


 * 1) Montage électronique de la gâche
 * 2) Acquisition et Reconnaissance des données
 * 3) IHM de pilotage de la gâche

Pour la réalisation de la phase d’acquisition, les travaux se sont appuyés sur le TP Biométrie préparatoire à ce projet. Les signaux de départ correspondent aux voix des membres du groupe enregistrées au format raw comme dans le TP. Les vecteurs paramètres de ces voix ont ensuite été générés grâce à l’outil spro, puis le modèle du monde créé en suivant les étapes décrites dans le TP préparatoire. Les modèles de locuteurs correspondant à ces 12 voix qui seront reconnues par le système ont également été créés. L’an dernier, en plus de l’acquisition des signaux de 12 membres du groupe, deux scripts ont été également faits pour  l’acquisition du signal d’un nouveau locuteur et la reconnaissance d’un locuteur quelconque par le système. Le script d’acquisition de signaux permet donc  d’enregistrer le signal d’un nouveau locuteur, de créer le vecteur de paramètre, de traiter le signal (normaliser, détecter l’énergie, renormaliser) et de l’ajouter au modèle du monde. Lors de l’acquisition le locuteur peut choisir d’être reconnu par le système ou non. S’il souhaite être reconnu alors son modèle de locuteur est généré. Une méthode java permettant d'exécuter un script shell a été réalisée mais nous ne disposons pas de cette méthode dans la documentation fournie. Le script de reconnaissance du locuteur permet de tester l’appartenance d’un locuteur au système. Il enregistre le signal du locuteur pendant quelques secondes, crée le vecteur de paramètres, traite le signal (normalisation, détection de l'énergie, re-normalisation) puis teste, en fonction de son nom, si ce locuteur est reconnu par le système ou non. Vu que cette partie du projet a été bien réussie, nous réutiliserons, les 2 scripts fournis. Pour ne pas avoir à chercher en permanence des personnes extérieures à notre système pour les tests, nous utiliserons les membres de notre groupe de 6 : 4 locuteurs reconnus par le système et 2 imposteurs.

Concernant l'IHM réalisée l'année précédente, il existe 2 modes distincts:
 * 1) Le mode acquisition qui sert à récupérer le signal et créer un modèle à partir de celui-ci.
 * 2) Le mode test qui sert d’identification. L’authenticité de l’utilisateur est vérifiée en comparant au modèle enregistré. Ces modes sont aussi utilisés dans notre application, mais l’interface est différente.

Mode acquisition :

Il faut entrer le nom de l’utilisateur et la durée souhaitée de l’enregistrement. En dessous se trouve un texte important que l’utilisateur doit lire, après avoir lancé l’enregistrement à l’aide d’un bouton. Le problème de ce type d’interface vient du texte à lire. En effet, celui-ci représente un pavé énorme, pas forcément facile à lire pour l’utilisateur. Il serait plus aisé de lire plusieurs phrases courtes, apparaissant l’une après l’autre, plutôt que de lire cet imposant paragraphe.

Mode test :

Il y a un champ disponible pour l’identifiant de l’utilisateur, ainsi qu’un slider permettant de définir le seuil. Une fois le nom entré et le seuil réglé, l’utilisateur lance l’enregistrement à l’aide d’un bouton. Il prononce alors la phrase de son choix (environ 3secondes).

Ce modèle possède des défauts. Le plus flagrant est de donner à l’utilisateur le choix du réglage du seuil :

-   Il ne sait pas forcément ce qu’est ce seuil, et ne comprend donc pas l’utilité du slider.

-   S’il connait l’utilité, il peut alors le régler pour essayer de fausser la reconnaissance.

Les développeurs de cette précédente version ont précisé qu’il s’agissait d’une interface de « test » et non « d’identification », ce qui explique les libertés données à l’utilisateur.

Le second défaut est la liberté donnée pour la phrase à dire :

-   D’un point de vue purement IHM, il est moins déroutant (et donc plus rapide) pour l’utilisateur de réciter une phrase affichée que d’en inventer une.

-   D’un point de vue reconnaissance vocale, il est aussi plus facile de comparer une phrase connue au modèle. On limite aussi les risques (phrase trop courte par exemple).

Solution

Pour la démonstration du projet, nous réaliserons une interface graphique qui permettra l'enregistrement des voix ainsi que leur reconnaissance. Puis de manipuler l’ensemble du matériel fourni. De plus nous afficherons différents diagramme à fin d’évaluer la robustesse de notre système notamment en termes de fausse acceptation et faux rejet. Tout en gardant à l’esprit ce qui a été réalisé l’an passé, ce qui faut garder ce qu’il faut éviter.

Enoncé du besoin
Le but d’un tel système est de protéger l’accès à des lieux, donnés,... (Ici permet la manipulation d’une gâche). Mais également d’évaluer les performances de ce système en faisant varier le différent paramètre d’enregistrement et de comparaison puis de générer des statistiques pour analyses.

Environnement du produit recherché
Pour réaliser ce projet, nous disposons:

Matériel
Gâche électrique Serrure électrique, alimenté en 12V. Elle se débloque lorsqu’elle reçoit un courant continu de 12V et se bloque si elle n’est pas alimentée.

Arduino

Une sortie digitale (aussi appelée « pin ») sur une carte Arduino permet une commande à deux états pouvant être « haut » et « bas ». Quand on envoie un signal « haut » à une sortie digitale, alors cette dernière sera alimentée en 5V, tandis qu’au contraire, si un signal « bas » correspondra à une tension nulle. Ainsi, selon la configuration de notre câblage, un signal haut correspondra à l’ouverture de la gâche électrique, et un signal bas correspondra à sa fermeture.

Batterie

Permet d’alimenter en 12V la gâche électrique, lorsque l’Arduino envoie un signal « haut » et ainsi de l’ouvrir.

'Breadborad

Quelques cables

Répartition des tâches
Nous avons réparti les différentes parties sur les différents membres du groupe. Nous allons démarrer en parallèle les trois parties: Montage, acquisition et IHM afin de gagner un maximum de temps. Une fois ces parties finies, on se penchera tous sur l'interfaçage entre l'IHM et les scripts de reconnaissance ainsi que les tests de performances. Voici les rôles de chaque membre de l'équipe:

Chef de projet:
 * 1) NAHUM Solis

Développeurs Acquisition/ Reconnaissance:
 * 1) MALKAS Benjamin
 * 2) NAHUM Solis
 * 3) EL BAKKOURI Nysrine

Montage gâche:
 * 1) ODUL Jonathan
 * 2) SEISSON Julien

Développement IHM:
 * 1) ODUL Jonathan
 * 2) RIOT Emilien
 * 3) SEISSON Julien

Responsable documentation (wiki+ppt):
 * 1) EL BAKKOURI Nysrine
 * 2) SEISSON Julien
 * 3) RIOT Emilien

Fonctionnalité matérielle
Montage électronique de la gâche

Description Cette partie consiste à réaliser un simple montage électronique qui nous permettra de tester le système à la fin du projet.

Objectif L’objectif est de piloter la gâche électrique depuis un PC en passant par une carte Arduino. Cette dernière devra donc être reliée à un PC en série (via USB), et la gâche électrique branchée à une sortie digitale du microcontrôleur. La carte Arduino devra être pourvue d’un programme qui sera en mesure d’acquérir les commandes reçues via le port série, donc du PC, et ainsi, après interprétation, envoyer un signal d’ouverture ou de fermeture à la gâche. La réalisation d’un programme sur PC sera nécessaire dans le but de pouvoir envoyer sur le port série, correspondant à la carte Arduino, les commandes d’ouverture et de fermeture. Pour cela, il existe la librairie RXTX permettant cela dans un programme Java. De plus, avec cette librairie, nous pouvons trouver beaucoup de tutoriels sur internet expliquant son utilisation pour communiquer avec une carte Arduino depuis un programme Java. En regroupant toutes ces technologies, nous devrions être en mesure de piloter depuis un programme Java tournant sur un PC, la gâche électrique.

Afin de faire fonctionner le système, la carte Arduino devra inclure un programme compilé permettant ces actions : -   Initialisation de la communication sur le port série -   Initialisation de la sortie digitale correspondant au branchement de la gâche électrique -   Lire en continue les données reçues via le port série : o   Si commande ‘o’ reçue, envoyer signal haut à la sortie digitale o   Si commande ‘c’ reçue, envoyer signal  bas à la sortie digitale

Programme Java Afin de communiquer avec la carte Arduino, la librairie RXTX est nécessaire. L’objectif ici est simplement de créer une fonction envoyant la commande ‘o’ à la carte Arduino pour ouvrir la gâche électrique, ou bien la commande ‘c’ pour la fermer. Un tutoriel complet est disponible à cette adresse http://arduino.cc/playground/Interfacing/Java expliquant comment établir une communication entre un programme Java et une carte Arduino. Dans notre projet, l’environnement utilisé est un environnement Windows, ainsi certaines des indications qui suivront ne sont valables seulement pour cet environnement. Pour faire de même dans un autre environnement, se reporter au tutoriel indiqué ci-dessus. Pour utiliser RXTX dans un projet Java, cela nécessite plusieurs choses à faire : -   ajouter la librairie RXTXcomm.jar de RXTX dans le buildpath du projet ; -   copier le fichier rxtxSerial.dll dans le répertoire du projet ; -   ajouter le paramètre « -Djava.library.path=. » dans les arguments de la JVM. Le chemin doit correspondre à l’emplacement du fichier .dll copié auparavant. Par la suite, il faut aussi que les drivers de la carte Arduino soient installés et que cette dernière soit reconnue par le PC en tant que port COM. De plus, il faudra bien noter quel numéro est attribué au port de la carte Arduino lors de l’installation du matériel (COMX). Il est aussi possible de le voir dans la liste des matériels du PC. En effet, il servira à indiquer dans le programme à quelle adresse joindre la carte Arduino.

Acquisition et Reconnaissance des données
Cette partie demande la mise en place de l'environnement de travail, pour cela, il faut faire le TP: http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/ qui explique bien toutes les étapes d'installation.

Fonctionnalités de l'IHM

 * Réglage du seuil de tolérance de comparaison
 * Bouton de lancement des enregistrements
 * Bouton d'arrêt des enregistrements
 * Enregistrement/Exécution des fichiers sonores
 * Gestion des utilisateurs

Affichage


 * État du système visible via pictogrammes explicite
 * Visibilité des logins utilisateurs
 * Distance au seuil
 * Informations complémentaires facilitant les actions

Algorithmique
Concernant l’enregistrement, nous reprendrons le travail effectué l’an passé pour identifier une personne. Notre ajout intervient au niveau d’une fonction qui calcule le seuil d’enregistrement en fonction des résultats obtenus.

IHM
L’interface sera réalisée en java avec la librairie SWING.

Voici quelques schémas de l'écran du système envisagé:

Enregistrement lancé


=Réalisation finale=

A l’issus de notre projet voici le travail réalisé sur les différentes parties.

Matériel


Au niveau matériel nous avons suivi l’ensemble des tutoriels que nous avions trouvé et effectué le montage fourni par Florian Thonnat, Electronicien de Polytech’Grenoble. Voici un lien vers une petite vidéo que nous avons réalisé montrant les différents composants du montage ainsi que le fonctionnement de celui-ci:

Lien vers la vidéo réalisée

A cela s'ajoute le code arduino réalisé pour piloter la gâche:

while (Serial.available) {     char key = Serial.read; switch (key) {       case 'o': digitalWrite(gachePin, HIGH);  // ouvre gache break; case 'c': digitalWrite(gachePin, LOW);   // ferme gache break; default: break; }   }   }

Pour un coté plus pratique du résultat final nous avons réutilisé le coffre fort qui avait été monté pour le projet touchKey. Celui-ci utilisant une gâche électrique nous avons réussi à relié notre montage à cette dernière.



Algorithmique
Algorithme du K-fold pour le réglage du seuil

Entrée : Une liste de comparaison

Sortie : Valeur pour le seuil

** On obtient 1 partie de test et (N*1) parties d'apprentissage ** On prend les scores des (N*1) parties de d'apprentissage ** On classe les scores par ordre croissant ** On trouve les intersections (moyenne précédent/suivant) entre scores des (N*1) parties d’apprentissage ** Pour chacune des intersections on calcule le nombre de faux positif, vrai positif, faux négatif, vrai négatif sur la partie de test courante
 * On découpe en N parties choisit aléatoirement le fichier de comparaison
 * Pour chacune des N parties:
 * On obtient le nombre de faux positif, vrai positif, faux négatif, vrai négatif pour l'ensemble des comparaisons (pour les N parties)
 * On calcule le rappel, précision, F*mesure (voir la page wikipedia en anglais : précision recall)
 * On trace la courbe roc
 * On trouve le meilleur seuil (au coude qui se forme généralement, il peut être avec le croisement avec la droite X=Y)
 * On prend la moyenne/médiane des meilleurs seuils *> seuil à utiliser pour la suite
 * Lorsqu'un nouvel enregistrement est effectué on test avec le seuil trouvé précédemment *> choix du système
 * On recommence l'algo en ajoutant le nouvelle enregistrement dans le corpus avec un découpage en N parties aléatoires différentes mais avec le même nombre N de partie

Pour le choix de N cela dépend du nombre de comparaison (On prend 10 dans notre cas)
 * On fais la moyenne de tous les seuils des parties d'apprentissage pour avoir le seuil optimal

IHM
La solution finale proposée est découpée en deux IHM distinctes. Une première qui est l'interface d'authentification, que l'utilisateur utilisera pour commander la gâche. Et la seconde qui est l'interface d'administration, utilisé pour gérer les utilisateurs que l'on supposera utiliser accompagné d'un administrateur pour faire l'ensemble des réglages nécessaires. Pour se faire nous avons implémenté nos interfaces en Java avec la librairie SWING.

IHM d'authentification
C'est cette interface que va principalement être utilisé. Nous avons choisi de l'apparenter à une interface d'accès à un bâtiment sécurisé. Nous avons supposé qu'un tel système pourrait se trouver en bas d'un immeuble sur une surface tactile. Notre interface a donc pour conséquence un minimum de boutons et un minimum d'action à effectuer pour lancer un test d'authentification.



Cette interface va à l'essentiel avec seulement 3 boutons cliquables. 2 boutons qui permettent de parcourir la liste des logins enregistrés et 1 pour lancer/arrêter l'enregistrement de la phrase d'authentification. On peut ensuite suivre l'état du système via plusieurs repère, la couleur du cadenas (bleu pour neutre, vert si personne reconnu par le système, rouge si rejeté par le système), le mouvement de la bobine (tourne si enregistre et immobile sinon), à noter l'apparition d'une phrase à lire dans la zone prévu et le changement du texte dans le bouton gérant le lancement et l'arrêt de l'enregistrement.

Processus d'authentification via l'ihm:


 * Sélection du login dans la liste défilante via des boutons permettant d'incrémenter ou décrémenter la liste. (Cadenas bleu pour état neutre avec bobine d'enregistrement immobile)
 * Cliquer sur le bouton de lancement d'enregistrement (Cadenas bleu, la bobine se met à tourner)
 * L'utilisateur lit la phrase qui apparait dans le textArea prévu à cet effet (Cadenas bleu, la bobine tourne toujours)
 * Cliquer sur le bouton de fin d'enregistrement (Cadenas bleu, la bobine s'arrête de tourner)
 * Retour du résultat (Cadenas vert cadenas rouge respectivement identifié ou pas, bobine arrêtée)

INSÉRER CAPTURE ACCEPTATION ACCÈS

INSÉRER CAPTURE REFUS ACCÈS

IHM d'administration
C'est cette interface qui va permettre la gestion des utilisateurs et le réglage du seuil de comparaison.

L'interface se présente sous plusieurs onglets:

Onglet seuil

Utilisation d'un slider, afin de modifier manuellement le seuil si l'administrateur le souhaite.



Onglet utilisateur

C'est à partir de cet onglet, que l'on peut gérer les utilisateurs.
 * Ajouter un nouvel utilisateur : L'administrateur doit renseigner l'ensemble des champs nécessaires puis effectuer la phase d'enregistrement des fichiers audio. Une nouvelle fenêtre s'affiche dans cet onglet. Cette fenêtre est similaire à la fenêtre d'authentification, on peut parcourir l'ensemble des phrases et faire un enregistrement pour chacune d'elles. Il est à noté que la liste des phrases est généré aléatoirement à partir d'un corpus de phrase stocké dans un fichier xml.




 * Modifier un utilisateur existant : Si l'administrateur choisit de modifier un utilisateur, il arrive sur la même fenêtre que pour ajouter un nouvel utilisateur sauf que les champs sont pré*remplis.