https://air.imag.fr/api.php?action=feedcontributions&user=Conqm&feedformat=atomair - User contributions [en]2024-03-28T18:45:57ZUser contributionsMediaWiki 1.35.13https://air.imag.fr/index.php?title=MIAMager&diff=2161MIAMager2011-05-05T08:17:44Z<p>Conqm: /* Démarche/Déroulement ... */</p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
Pour le projet Multimédia de l’année 2010-2011, nous avons conçu une application de gestion de refrigerateur et de liste de course, nous avons tout d’abord décidé le sujet en partant sur différentes solutions d’aide au management de frigo, nous nous sommes finalement mis d’accord sur une idée d'application mobile offrant a l'utilisateur diverses fonctionnalités pour gerer ses denrees et ameliorer son experience lors de ses courses !<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
Pour la réalisation de ce projet, la démarche a été straight forward. <br />
<br />
<br />
1 brainstorming pour le choix du sujet.<br />
<br />
1 étude de l'existant.<br />
<br />
2 interviews in-situ. <br />
<br />
4 interviews ex-situ.<br />
<br />
5 brainstorming pour debrieffer les interviews et dénicher les idées à garder<br />
<br />
La préparation d'un prototype animé powerpoint pour se rapprocher le plus possible d'une interface réelle.<br />
<br />
<br />
Voici la recette du projet MIAMager.<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
[[Media:Presentation.tar]]<br />
<br />
Note : rajoutez l'extension .bz2 pour decompresser. En effet l'upload du wiki est en bois.</div>Conqmhttps://air.imag.fr/index.php?title=MIAMager&diff=2160MIAMager2011-05-05T08:15:35Z<p>Conqm: /* Supports */</p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
Pour le projet Multimédia de l’année 2010-2011, nous avons conçu une application de gestion de refrigerateur et de liste de course, nous avons tout d’abord décidé le sujet en partant sur différentes solutions d’aide au management de frigo, nous nous sommes finalement mis d’accord sur une idée d'application mobile offrant a l'utilisateur diverses fonctionnalités pour gerer ses denrees et ameliorer son experience lors de ses courses !<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
Pour la réalisation de ce projet, la démarche a été straight forward. <br />
<br />
<br />
1 brainstorming pour le choix du sujet.<br />
<br />
1 etude de l'existant.<br />
<br />
2 interviews in-situ. <br />
<br />
4 interviews ex-situ.<br />
<br />
5 Brainstorming pour debrieffer les interviews et dénicher les idées à garder<br />
<br />
La préparation d'un prototype animé powerpoint pour se rapprocher le plus possible d'une interface réelle.<br />
<br />
<br />
Voici la recette du projet MIAMager.<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
[[Media:Presentation.tar]]<br />
<br />
Note : rajoutez l'extension .bz2 pour decompresser. En effet l'upload du wiki est en bois.</div>Conqmhttps://air.imag.fr/index.php?title=MIAMager&diff=2159MIAMager2011-05-05T08:15:20Z<p>Conqm: /* Démarche/Déroulement ... */</p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
Pour le projet Multimédia de l’année 2010-2011, nous avons conçu une application de gestion de refrigerateur et de liste de course, nous avons tout d’abord décidé le sujet en partant sur différentes solutions d’aide au management de frigo, nous nous sommes finalement mis d’accord sur une idée d'application mobile offrant a l'utilisateur diverses fonctionnalités pour gerer ses denrees et ameliorer son experience lors de ses courses !<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
Pour la réalisation de ce projet, la démarche a été straight forward. <br />
<br />
<br />
1 brainstorming pour le choix du sujet.<br />
<br />
1 etude de l'existant.<br />
<br />
2 interviews in-situ. <br />
<br />
4 interviews ex-situ.<br />
<br />
5 Brainstorming pour debrieffer les interviews et dénicher les idées à garder<br />
<br />
La préparation d'un prototype animé powerpoint pour se rapprocher le plus possible d'une interface réelle.<br />
<br />
<br />
Voici la recette du projet MIAMager.<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
[[Media:Presentation.tar]]<br />
<br />
pipi caca vomi<br />
<br />
Note : rajoutez l'extension .bz2 pour decompresser. En effet l'upload du wiki est en bois.</div>Conqmhttps://air.imag.fr/index.php?title=MIAMager&diff=2156MIAMager2011-05-05T08:13:58Z<p>Conqm: /* Démarche/Déroulement ... */</p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
Pour le projet Multimédia de l’année 2010-2011, nous avons conçu une application de gestion de refrigerateur et de liste de course, nous avons tout d’abord décidé le sujet en partant sur différentes solutions d’aide au management de frigo, nous nous sommes finalement mis d’accord sur une idée d'application mobile offrant a l'utilisateur diverses fonctionnalités pour gerer ses denrees et ameliorer son experience lors de ses courses !<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
Pour la réalisation de ce projet, la démarche a été straight forward. <br />
<br />
<br />
1 brainstorming pour le choix du sujet.<br />
<br />
1 etude de l'existant.<br />
<br />
2 interviews in-situ. <br />
<br />
4 interviews ex-situ.<br />
<br />
5 Brainstorming pour debrieffer les interviews et dénicher les idées à garder<br />
<br />
La préparation d'un prototype animé powerpoint pour se rapprocher le plus possible d'une interface réelle.<br />
<br />
<br />
Voici la recette du projet MIAMager.<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
[[Media:Presentation.tar]]<br />
<br />
pipi caca vomi<br />
<br />
Note : rajoutez l'extension .bz2 pour decompresser. En effet l'upload du wiki est en bois.</div>Conqmhttps://air.imag.fr/index.php?title=MIAMager&diff=2155MIAMager2011-05-05T08:13:46Z<p>Conqm: /* Démarche/Déroulement ... */</p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
Pour le projet Multimédia de l’année 2010-2011, nous avons conçu une application de gestion de refrigerateur et de liste de course, nous avons tout d’abord décidé le sujet en partant sur différentes solutions d’aide au management de frigo, nous nous sommes finalement mis d’accord sur une idée d'application mobile offrant a l'utilisateur diverses fonctionnalités pour gerer ses denrees et ameliorer son experience lors de ses courses !<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
Pour la réalisation de ce projet, la démarche a été straight forward. <br />
<br />
<br />
prout prout prout<br />
<br />
<br />
1 brainstorming pour le choix du sujet.<br />
<br />
1 etude de l'existant.<br />
<br />
2 interviews in-situ. <br />
<br />
4 interviews ex-situ.<br />
<br />
5 Brainstorming pour debrieffer les interviews et dénicher les idées à garder<br />
<br />
La préparation d'un prototype animé powerpoint pour se rapprocher le plus possible d'une interface réelle.<br />
<br />
<br />
Voici la recette du projet MIAMager.<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
[[Media:Presentation.tar]]<br />
<br />
pipi caca vomi<br />
<br />
Note : rajoutez l'extension .bz2 pour decompresser. En effet l'upload du wiki est en bois.</div>Conqmhttps://air.imag.fr/index.php?title=MIAMager&diff=2140MIAMager2011-05-04T15:56:57Z<p>Conqm: </p>
<hr />
<div>* UE/Module: Projet Multimédia RICM4 option CM<br />
* Enseignant RICM : Renaud Blanch<br />
* Élèves RICM5 : CONQ Maxime / COUDURIER Frédéric / DUPIN Frédéric / HARTNAGEL Jonathan / MERIADEC Cédric<br />
<br />
en 500-1000 mots<br />
<br />
==Description==<br />
<br />
==Démarche/Déroulement ...==<br />
<br />
==Supports==<br />
* Présentation (PPT,ODP, ...)<br />
* [http:// site complet du projet]<br />
* Photos<br />
* Vidéo<br />
* Flyer<br />
* Poster<br />
* ...</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1463PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:13:07Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
#:<br />
#:Il ne nous reste plus qu'à lire ce fichier result en java, de comparer la valeur que nous trouvons avec le seuil fixé préalablement par l'utilisateur et d'ouvrir ou non la porte en fonction de ce résultat.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1462PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:03:03Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1461PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:02:22Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm.<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1460PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:01:26Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#:Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1459PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:00:58Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#::Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#::Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue.<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1458PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T17:00:22Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#::Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#::Nous utilisons ici un nouveau fichier locuteur.ndx (de la même forme que le fichier locuteurs.ndx explicité précédemment) qui contient seulement le nom de la personne qui souhaite être reconnue <br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1457PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:58:07Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Ensuite, nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm). Nous créons alors un modèle pour chacun de ces locuteurs en combinant le modèle du monde avec un fichier audio (.raw) de chacun des locuteurs (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Cela nous crée pour chacun des locuteurs acceptés par le sytème un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteur.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#::Cela nous enregistre dans le fichier locuteur.res un ensemble de valeurs dont le résultat final qui nous intéresse.<br />
#::Nous utilisons ici un nouveau fichier locuteur.ndx qui contient seulement le nom de la personne qui souhaite être reconnue<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1456PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:45:10Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichiers de configuration donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1455PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:43:08Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1454PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:42:34Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous donne ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1453PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:41:49Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On place la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1452PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:38:32Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite pouvoir être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On récupère la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1451PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:36:02Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''# On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''# On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''# On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''# On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''# On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''# On regarde si le locuteur souhaite être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''# Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''# On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''# On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''# On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''# On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''# On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''# On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''# On récupère la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1450PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T16:31:22Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''% On se place dans le bon dossier''<br />
#::''cd algo/output_files''<br />
#::''% On vérifie que le nom entré n'est pas déjà dans la liste pour ne pas l'écraser''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''% On enregistre le nouveau locuteur''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''% On crée le vecteur de paramètre''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''% On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''% On ajoute le nom du locuteur dans le fichier all.lst''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''% On crée le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''% On regarde si le locuteur souhaite être reconnu par le système<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''% Si c'est le cas, alors on l'ajoute dans le fichier locuteurs.ndx pour que son modèle soit généré''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''% On re-génère les modèles des locuteurs acceptés par le système avec le nouveau modèle du monde''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''% On se place dans le bon dossier''<br />
#::''cd algo/output_files/''<br />
#::''% On enregistre le locuteur qui souhaite être reconnu''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''% On crée le vecteur de paramètre''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''% On traite le signal (normalisation, détection d'énergie, re-normalisation)''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''% On effectue un test de reconnaissance sur le locuteur''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''% On récupère la valeur qui nous intéresse dans le fichier result''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1449PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:50:17Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files/''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui effectue le test de reconnaissance<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1448PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:49:20Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files/''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1447PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:47:45Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''res (dossier des résultats des tests de reconnaissance)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close. Là encore, nous avons écrit un script qui enregistre le 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. Enfin, nous enregistrons le résultat dans un fichier de résultat d'extension .res dans le dossier res et récupérons seulement la valeur qui nous intéresse dans un fichier nommé result (lui aussi dans le dossier res).<br />
<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files/''<br />
#::''brec -r -b 16 -s 16000 -t 3 ./input/$1.raw''<br />
#::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./input/$1.raw ./prm/$1.prm''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/$1.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/$1.res --debug false --verbose true''<br />
#::''awk '{print $NF}' ./res/$1.res > ./res/result''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1446PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:37:46Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#::* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#::* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#::* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#: <br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1445PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:36:31Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#:* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#:* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#:* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1444PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:35:17Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i '''$1''' ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t '''$2''' ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ '''$3''' -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
#:Avec :<br />
#:* $1 (1er paramètre) : nom du locuteur qui s'ajoute au système<br />
#:* $2 (2ème paramètre) : Durée de l'enregistrement<br />
#:* $3 (3ème paramètre) : 1 si le locuteur souhaite être accepté par le système, et 0 sinon<br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1443PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:29:00Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
<br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1442PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:27:51Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système. Pour cela, nous avons écrit un script shell qui enregistre un signal d'une durée définie par l'utilisateur, avec le nom qu'il souhaite lui donner ainsi que son souhait d'être accepté ou non par le système.<br />
#::''#!/bin/bash''<br />
#::''cd algo/output_files''<br />
#::''if ! grep -i $1 ./lst/all.lst''<br />
#:::''then''<br />
#::::''brec -r -b 16 -s 16000 -t $2 ./../input_files/$1.raw''<br />
#::::''sfbcep -F PCM16 -f16000 -p 19 -e -D -A ./../input_files/$1.raw ./prm/$1.prm''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --i<br />
nputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --i<br />
nputFeatureFilename $1 --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetec<br />
tor.cfg --inputFeatureFilename $1 --verbose true --debug false''<br />
#::::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFea<br />
tureFilename $1''<br />
#::::''echo $1 >> ./lst/all.lst''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg <br />
--inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename wor<br />
ld_init --debug false --verbose true''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg<br />
--inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename wo<br />
rld --inputWorldFilename world_init --debug false --verbose true''<br />
#::::''if [ $3 -ne 0 ]''<br />
#:::::''then''<br />
#::::::''echo $1 $1 >> ./ndx/locuteurs.ndx''<br />
#::::''fi''<br />
#::::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targ<br />
etIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::''fi''<br />
<br />
#:De plus, nous avons créé une méthode java permettant d'exécuter un script shell en lui passant les paramètres voulus.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée et la porte s'ouvre, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1441PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:18:51Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : '''acquisition''' et '''reconnaissance'''<br />
# '''Acquisition'''<br />
#:La phase d'acquisition nous permet d'enregistrer la voix d'une personne jusqu'alors absente du système, de l'ajouter au modèle du monde, et, si on le souhaite, de l'ajouter aux personnes reconnues par le système.<br />
# '''Reconnaissance'''<br />
#:C'est dans la partie reconnaissance que nous allons tester si une personne peut ouvrir la porte ou non. Pour cela, nous récupérons le nom de cette personne, nous enregistrons sa voix pendant quelques secondes, nous créons le vecteur de paramètres, le traitons (normalisation, détection d'énergie, re-normalisation) et effectuons un test avec son modèle de locuteur (s'il existe). Si le résultat est plus grand qu'un seuil (que nous pouvons fixer) alors la personne est acceptée, sinon, elle est refusée et la porte reste close.<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1440PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:10:53Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties : acquisition et reconnaissance<br />
# Acquisition<br />
#:<br />
# Reconnaissance<br />
#:<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1439PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:09:40Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties<br />
* Une partie appelée acquisition ()<br />
* Une partie appelée reconnaissance ()<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1438PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:09:02Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
Nous devons maintenant appliquer tout cela à notre projet.<br />
Notre système est divisé en 2 parties<br />
#* Une partie appelée acquisition ()<br />
#* Une partie appelée reconnaissance ()<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1437PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:05:14Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée et de la traiter (créer le vecteur de paramètres, normaliser, détecter l'énergie, re-normaliser) et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#: <br />
#: <br />
Ensuite<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1436PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:03:16Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:--------------------------------------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1435PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T15:02:04Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:-------------------------------------------------------------------------------------------------------<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* ''output_files''<br />
#:::* ''cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP''<br />
#:::* ''gmm (dossier des modèles)''<br />
#:::* ''lbl (dossier des labels)''<br />
#:::* ''lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)''<br />
#:::* ''ndx (dossier des index)''<br />
#:::* ''prm (dossier des vecteurs de paramètres, normalisés ou non)''<br />
#:::* ''LIA_RAL''<br />
#:::* ''input (dossier qui contiendra les voix de tests)''<br />
#:-------------------------------------------------------------------------------------------------------<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1434PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:51:53Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* output_files<br />
#:::* cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP<br />
#:::* gmm (dossier des modèles)<br />
#:::* lbl (dossier des labels)<br />
#:::* lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)<br />
#:::* ndx (dossier des index)<br />
#:::* prm (dossier des vecteurs de paramètres, normalisés ou non)<br />
#:::* LIA_RAL<br />
#:::* input (dossier qui contiendra les voix de tests)<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1433PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:51:35Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::* output_files -><br />
#:::* cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP<br />
#:::* gmm (dossier des modèles)<br />
#:::* lbl (dossier des labels)<br />
#:::* lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)<br />
#:::* ndx (dossier des index)<br />
#:::* prm (dossier des vecteurs de paramètres, normalisés ou non)<br />
#:::* LIA_RAL<br />
#:::* input (dossier qui contiendra les voix de tests)<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1432PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:51:09Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
#:''Pour la suite, il est important de suivre l'arborescence de dossiers utilisée pour le TP :''<br />
#::Dossier parent : output_files -><br />
#:::* cfg (dossier de config) contenant l'ensemble des fichier de configurations donnés dans le TP<br />
#:::* gmm (dossier des modèles)<br />
#:::* lbl (dossier des labels)<br />
#:::* lst (dossier des fichiers all.lst, world.lst (pointant juste le fichier all.lst), world.weight)<br />
#:::* ndx (dossier des index)<br />
#:::* prm (dossier des vecteurs de paramètres, normalisés ou non)<br />
#:::* LIA_RAL<br />
#:::* input (dossier qui contiendra les voix de tests)<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1431PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:42:46Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour des fichiers maxime.raw et maxime.gmm).<br />
#:<br />
#:<br />
# Salut<br />
<br />
<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1430PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:41:27Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Pour chacun d'eux, nous créons un fichier locuteur.ndx dans le dossier ndx qui contiendra le nom de ce locuteur. Nous créons alors un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de sa voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteur.ndx --inputWorldFilename world --debug false --verbose true''<br />
#::Nous effectuons cette opération pour chacun des locuteurs qui seront acceptés par le système. Cela nous crée pour chacun d'eux un fichier locuteur.gmm dans le dossier gmm<br />
#:<br />
# Une fois que sont créés ces modèles de locuteur, nous pouvons effectuer quelques tests.<br />
#:Pour cela, il suffit d'enregistrer la voix de la personne qui souhaite être identifiée, de créer le vecteur de paramètres, de normaliser, de détecter l'énergie, de re-normaliser le signal et d'appeler la commande ComputeTest :<br />
#::''./LIA_RAL/LIA_SpkDet/ComputeTest/ComputeTest.exe --config ./cfg/target_seg.cfg --ndxFilename ./ndx/locuteurs.ndx --worldModelFilename world --inputWorldFilename world --outputFilename ./res/locuteurs.res --debug false --verbose true''<br />
#:Le fichier locuteurs.ndx contient la liste des personnes qui sont acceptées par le système. Cette liste est de la forme : "nom_du_fichier_raw nom_du_fichier_gmm" (exemple : "maxime maxime" pour un fichier maxime.raw et maxime.gmm).<br />
<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1429PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:25:15Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Nous créons alors pour chacun d'eux un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de leur voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#:<br />
#* Septième étape, <br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1428PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:24:27Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector :<br />
#:::''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent :<br />
#:::''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Nous créons alors pour chacun d'eux un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de leur voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
#:<br />
#* Septième étape, <br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1427PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:22:35Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat : ''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector : ''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent : ''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre le modèle du monde<br />
#::Nous créons ici ce que l'on appelle le modèle du monde, c'est à dire que l'on fait une sorte de moyenne des 12 voix que nous avons préalablement enregistrées. Nous utilisons pour cela la commande TrainWorld qui se décompose en deux commandes :<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldInit.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world_init --debug false --verbose true''<br />
#:::''./LIA_RAL/LIA_SpkDet/TrainWorld/TrainWorld.exe --config ./cfg/TrainWorldFinal.cfg --inputStreamList ./lst/world.lst --weightStreamList ./lst/world.weight --outputWorldFilename world --inputWorldFilename world_init --debug false --verbose true''<br />
#::Cela crée le fichier world.gmm dans le dossier gmm<br />
#:<br />
#* Sixième étape, créer les modèles de locuteurs<br />
#::Tout d'abord, nous choisissons les locuteurs qui seront acceptés par le système. Nous créons un fichier locuteurs.ndx dans le dossier ndx qui contiendra les noms de ces locuteurs. Nous créons alors pour chacun d'eux un modèle de locuteur en combinant le modèle du monde avec un fichier audio (.raw) de leur voix (le même que celui enregistré pour créer le modèle du monde). Nous utilisons pour cela la commande TrainTarget : ''./LIA_RAL/LIA_SpkDet/TrainTarget/TrainTarget.exe --config ./cfg/target.cfg --targetIdList ./ndx/locuteurs.ndx --inputWorldFilename world --debug false --verbose true''<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1426PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T10:10:40Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
#:<br />
#* Deuxième étape, normaliser les paramètres de chacun des signaux<br />
#::Nous utilisons une nouvelle fois un outil fourni dans le TP : "LIA_RAL" ([http://mistral.univ-avignon.fr/build/LIA_RAL.tar]). Et nous utilisons la commande NormFeat : ''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat_energy.cfg --inputFeatureFilename ./lst/all.lst --debug false --verbose true''<br />
#::Cette commande crée les fichiers locuteur.enr.prm dans le dossier prm<br />
#:<br />
#* Troisième étape, détecter l'énergie de chacun des signaux<br />
#::Pour détecter cette énergie, nous allons utiliser la commande EnergyDetector : ''./LIA_RAL/LIA_SpkDet/EnergyDetector/EnergyDetector.exe --config ./cfg/EnergyDetector.cfg --inputFeatureFilename ./lst/all.lst --verbose true --debug false''<br />
#::Cette commande crée les fichiers locuteur.lbl dans le dossier lbl (labels)<br />
#:<br />
#* Quatrième étape, re-normaliser les paramètres<br />
#::On utilise une nouvelle fois la commande NormFeat, mais avec un fichier de configuration différent : ''./LIA_RAL/LIA_SpkDet/NormFeat/NormFeat.exe --config ./cfg/NormFeat.cfg --inputFeatureFilename ./lst/all.lst''<br />
#::Cette commande crée les fichiers locuteur.norm.prm dans le dossier prm<br />
#:<br />
#* Cinquième étape, apprendre les modèles du monde<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1425PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:51:47Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs).<br />
#::Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1424PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:51:01Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs). Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1423PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:50:30Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#:* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#::Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs). Et nous écrivons notre script : <br />
#:::foreach i (`cat all.lst`)<br />
#:::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#:::end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1422PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:49:40Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#:* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#:Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs). Et nous écrivons notre script : <br />
#::foreach i (`cat all.lst`)<br />
#::sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
#::end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1421PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:47:53Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#:* Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#:Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs). Et nous écrivons notre script : <br />
##:foreach i (`cat all.lst`)<br />
##:sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
##:end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqmhttps://air.imag.fr/index.php?title=PAGE_WIKI_ETUDIANTS_2010-11_SERRURE_VOCALE&diff=1420PAGE WIKI ETUDIANTS 2010-11 SERRURE VOCALE2011-03-03T09:45:48Z<p>Conqm: /* Analyse de la parole: */</p>
<hr />
<div>== Composition du groupe gache électrique // serrure vocale : ==<br />
<br />
<br />
Chefs de projet :<br />
#Florian FAUVARQUE<br />
#Marc VOLAINE<br />
<br />
Membres du groupe "IHM" :<br />
#Frédéric DUPIN<br />
#Jonathan HARTNAGEL<br />
#Cédric MERIADEC<br />
#Clément RIGNAULT<br />
<br />
Membres du groupe "ELECTRIQUE" :<br />
#Frédéric COUDURIER<br />
#Anthony DAMOTTE<br />
<br />
Membres du groupe "ALGORITHMIQUE" :<br />
#Maxime CONQ<br />
#Raphaëlle DIDIER<br />
#Floriane PIHUIT<br />
<br />
== Gâche électronique: ==<br />
<br />
Cette partie a pour but d'expliquer et d'illustrer le fonctionnement de la gâche électronique. Des comptes-rendus et documentations supplémentaires sont disponibles en annexe.<br />
<br />
[[File:Gache.jpg|200px|thumb|Gache électrique pour biométrie]]<br />
# La gâche électrique:<br />
#:<br />
#: La gâche électrique provient d'un projet réalisé par les étudiants RICM5 promotion 2010 intitulé : TouchKey.<br />
#:<br />
#:* Gache électrique réversible gauche ou droite.<br />
#:* Dimension du corps: 160x25x30 en aluminium inoxidable donc garde le même aspect trés longtemps<br />
#:* Fonctionne en 10VDC avec une tolérance importante de 20% soit entre 8 volts et 12 volts permettant toujours d'être très adaptable a de nombreuses installations.<br />
#:* Température de fonctionnement: de - 15 degrée centigrade à + 50 degrée centigrade<br />
#:<br />
# Le circuit électronique:<br />
#:<br />
#: Le circuit électronique provient également du projet TouchKey.<br />
#:<br />
#:* Contenu : 2 résistances (820 et 220 Ohms), un transistor NPN et l'adaptateur alimentation.<br />
#:* Schéma : [[Schéma électronique]]<br />
#:* Alimentation : est fourni avec le circuit un transformateur courant alternatif 220 - continu 9V.<br />
#:<br />
# La conversion numérique/analogique (CAN)<br />
#:<br />
#:* Technologies utilisées : JAVA, USB, Port série<br />
#:* Sources du code : <br />
<br />
<br />
<br />
[[Gachette electrique]] - Cahier des charges / Schéma du montage<br />
<br />
== Analyse de la parole: ==<br />
<br />
Le but du projet est de permettre à certains locuteurs préalablement enregistrés dans le système d'ouvrir une porte simplement '''par la parole'''. C'est ici qu'entre en jeu la phase d'analyse. Avant de commencer le projet, nous avons étudié les TPs de biométrie de l'année dernière ([http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]) ainsi que plusieurs compte-rendus de précédents étudiants que l'on nous a fournis. Cela nous fournit ainsi toutes les étapes ainsi que la marche à suivre en ce qui concerne la reconnaissance de locuteurs. Enfin, nous avons vu dans les comptes rendus de TPs que les résultats sont meilleurs lorsque l'on normalise et que l'on détecte l'énergie des signaux, nous ferons de même pour notre projet.<br />
<br />
Voici les différentes étapes de la reconnaissance d'un locuteur :<br />
<br />
# Tout d'abord, nous récupérons un ensemble de voix qui nous servira à créer un modèle du monde. Nous avons utilisé les voix des membres du projet (ce qui nous donne 12 voix : 9 d'hommes et 3 de femmes). Pour cela, nous utilisons un logiciel en ligne de commande sous linux qui se nomme ''bplay'' ([http://www.hitsquad.com/smm/programs/bplay/]), et la commande pour enregistrer une voix : ''brec -r -b 16 -s 16000 -t 60 locuteur.raw'' : "-b 16" pour préciser le nombre de bits, "-s 16000" pour préciser la fréquence (16kHz) et "-t 60" pour enregistrer 60 secondes de signal. A remarquer également que le fichier enregistré a une extension en .raw ; nous avons choisi cela car c'est le même format que pour les TPs. Nous pouvons également écouter le signal enregistré avec la commande : bplay -b 16 -s 16000 locuteur.raw<br />
#:<br />
# Maintenant que nous avons enregistré ces 12 voix (extension .raw), nous allons '''traiter''' ces signaux.<br />
#:Première étape, générer les vecteurs de paramètres pour chacun des signaux.<br />
#:Pour cela, nous utilisons un outil fourni dans le TP : spro ([http://www.irisa.fr/metiss/guig/spro/download.html]) qui propose une commande ''sfbcep -F PCM16 -f16000 -p 19 -e -D -A locuteur.raw locuteur.prm'' qui va créer un vecteur de paramètres pour le fichier locuteur.raw. Comme nous avons 12 signaux, donc 12 vecteurs à générer, nous allons créer un script csh. Pour cela, nous plaçons tout d'abord dans un fichier all.lst la liste des noms des signaux (noms des locuteurs). Et nous écrivons notre script : <br />
##:foreach i (`cat all.lst`)<br />
##:sfbcep -F PCM16 -f16000 -p 19 -e -D -A $i.raw $i.prm<br />
##:end<br />
<br />
<br />
<br />
<br />
<br />
<br />
Cette partie a pour but d'expliquer l'algorithme de reconnaissance de la parole. Nous allons résumer le tp de biométrie [http://www-clips.imag.fr/geod/User/laurent.besacier/NEW-TPs/TP-Biometrie/]<br />
Des compte-rendus sont disponibles en annexe.<br />
<br />
# Reconnaissance des genres:<br />
#:<br />
#:Suite à l’analyse des TPs disponibles nous pouvons déclarer que pour une bonne reconnaissance de genre (la parole est de type male ou femelle) il faut :<br />
#:* Normaliser les paramètres<br />
#:* Détecter l’énergie<br />
#:<br />
#:Nous gardons ces caractéristiques pour l'élaboration du projet.<br />
#:<br />
# Reconnaissance du locuteur:<br />
#:<br />
#:Pour cette partie, nous disposons de 3 femmes et 9 hommes. Nous procédons de la manière suivante:<br />
#:*Récupération des voix<br />
#:*Création du modèle monde<br />
#:*Création du modèle d'une personne<br />
## Récupération des voix<br />
##:On utilise l'application B-Play(lien à rajouter) sous Linux. On enregistre chaque locuteur lisant le même texte d'une durée d'une minute dans un fichier.<br />
##: '''Commande d'enregistrement''' :'' commande ''<br />
## Création du modèle monde<br />
##:<br />
##:On utilise les voix enregistrées pour créer le modèle monde.<br />
##:''' Commande création modèle monde ''':'' commande ''<br />
##Création du modèle d'une personne<br />
##: Pour créer le modèle d'une personne en particulier, nous combinons (phase d'adaptation) la voix au modèle monde pour extraire le modèle de la personne.<br />
##: '''Commande apprentissage''' :'' commande ''<br />
<br />
== Interface Graphique ==<br />
<br />
Consultez la page dédiée ci dessous<br />
<br />
[[Interface graphique du client]] - Cahier des charges / Esquisses de l'IHM</div>Conqm