SamoWeb Création d'une plateforme Web de partage et de traitement de fichiers audio - IRIT
←
→
Transcription du contenu de la page
Si votre navigateur ne rend pas la page correctement, lisez s'il vous plaît le contenu de la page ci-dessous
M1 Systèmes Interactifs
et Robotique
IRIT – Université Toulouse 3
Paul Sabatier
118 Route de Narbonne
31 062 Toulouse Cedex 9
RAPPORT de STAGE
SamoWeb
Création d’une plateforme Web de partage et
de traitement de fichiers audio
avril 2015 – juillet 2015
Présenté et soutenu par
Tony DOIN
Tuteur de stage : Patrick DANÈS
Maître de stage : Julien PINQUIER
Rapport de stage 2015
2
Rapport de stage 2015
Remerciements
Je tiens tout d’abord à remercier mon maître de stage, Monsieur Julien Pinquier, responsable
de l’équipe SAMoVA au sein de l’IRIT pour m’avoir accueilli durant ces quatre mois de stage.
Je remercie tout particulièrement Maxime Le Coz et Patrice Guyot pour leurs conseils ainsi
que pour leur aide.
Je remercie également les autres membres de l’équipe qui ont contribué, de près ou de loin,
au bon déroulement de mes travaux durant ces quatre mois, et qui m’ont permis de m’intégrer
rapidement au sein de l'équipe.
3
Rapport de stage 2015
SOMMAIRE
Table des illustrations.............................................................................................................................. 5
Glossaire .................................................................................................................................................. 6
Introduction............................................................................................................................................. 8
I. Contexte professionnel ................................................................................................................... 9
1) Présentation de l’IRIT .................................................................................................................. 9
2) Présentation de l’équipe SAMoVA ............................................................................................ 10
3) L’environnement de travail ....................................................................................................... 10
II. Les outils d’analyse automatique .................................................................................................. 11
1) Descripteurs de détection de son environnemental ................................................................. 11
2) Les SamoCharts ......................................................................................................................... 12
3) Synthèse sonore ........................................................................................................................ 13
III. Plateforme Web ........................................................................................................................ 15
1) Les outils utilisés ........................................................................................................................ 15
2) Conception ................................................................................................................................ 16
3) Développement et intégration des modules d’analyses ........................................................... 20
i. Modèles ............................................................................................................................. 21
ii. Vues ................................................................................................................................... 22
iii. Templates .......................................................................................................................... 22
iv. Administration ................................................................................................................... 22
v. Intégration des outils d’analyse automatique................................................................... 23
4) Tests et résultats ....................................................................................................................... 25
IV. Travail restant............................................................................................................................ 30
Conclusion ............................................................................................................................................. 31
Références ............................................................................................................................................. 32
Annexes ................................................................................................................................................. 33
4
Rapport de stage 2015
Table des illustrations
Figure 1 : Descripteur d’un fichier audio pour les bruits de moteur..................................................... 11
Figure 2 : Equation du calcul de la taille des SamoCharts ..................................................................... 12
Figure 3 : SamoCharts basés sur les scores de confiance ..................................................................... 13
Figure 4 : SamoCharts basés sur l’énergie............................................................................................. 13
Figure 5 : Framework Django modèle MVT........................................................................................... 15
Figure 6 : Conception de la page d’accueil ............................................................................................ 17
Figure 7 : Conception de la page de dépôt d’un fichier ........................................................................ 17
Figure 8 : Conception de la page de corpus .......................................................................................... 18
Figure 9 : Conception de la page d’information d’un fichier ................................................................ 19
Figure 10 : Modèle de la plateforme Web ............................................................................................ 21
Figure 11 : Page administration du modèle FILE ................................................................................... 23
Figure 12 : Calcul des descripteurs pour l’énergie ................................................................................ 24
Figure 13 : Page d’accueil ...................................................................................................................... 25
Figure 14 : Page protocole expérimental .............................................................................................. 26
Figure 15 : Page de dépôt d’un fichier audio ........................................................................................ 26
Figure 16 : Visualisation SamoCharts confiance.................................................................................... 27
Figure 17 : Visualisation SamoCharts énergie ....................................................................................... 28
Figure 18 : Visualisation SamoCharts avec recherche et tri .................................................................. 28
Figure 19 : Page de détail d’un fichier audio ......................................................................................... 29
Figure 20 : Profil utilisateur ................................................................................................................... 29
5
Rapport de stage 2015
Glossaire
ANR
Agence Nationale de la Recherche. Elle a pour mission la mise en œuvre du financement de la
recherche pour les projets en France1.
CIESS
Constitution, Indexation et Enrichissement d’un corpuS de Sons de l’environnement.
Classe
Une classe déclare des propriétés communes à un ensemble d’objets. Un objet est créé à
partir d’une classe.
Déploiement
Fait de mettre en place un nouveau système ou un nouveau logiciel pour le client. Celui-ci
pourra accéder au logiciel.
Django
Django est un Framework Python destiné au Web.
Energie
L’énergie d’un signal est une caractéristique liée à la quantité de l’information représentée.
Nous pouvons construire une estimation de l’énergie à partir des amplitudes du signal.
Framework
Ensemble d’outils qui simplifie le travail d’un développeur. Il apporte les bases communes à
la majorité des programmes ou des sites Web.
Fonction
Méthode qui permet de retourner des valeurs ou non et qui comporte parfois des
paramètres d’entrée.
IDE (Environnement de Développement Intégré)
Environnement de développement qui rassemble des outils pour augmenter la productivité
des développeurs.
1
http://www.agence-nationale-recherche.fr/
6
Rapport de stage 2015
Ligne de commande
Une ligne de commande est une ligne saisie dans un terminal (console informatique). Elle
permet d'utiliser les différentes fonctionnalités proposées par le système d'exploitation (déplacer ou
supprimer un fichier, exécuter un programme…).
MVT (Modèle Vue Template)
Modèle d'architecture qui cherche à séparer nettement les couches de présentation
(interface utilisée par l’utilisateur), métier et d'accès aux données. Le but étant d'avoir une
dépendance minimale entre les différentes couches de l'application ; ainsi les modifications
effectuées sur n'importe quelle couche de l’application n'affectent pas les autres couches.
PyCharm
IDE pour la programmation en Python.
Python
Langage de programmation informatique.
Routage URL
Mise en place de liens URL qui permet la navigation sur la plateforme Web.
SVN
Subversion, également appelé SVN, est un système de gestion de version.
SamoChart
Nom donné au « graphe » permettant de visualiser des sons dans un environnement urbain.
Thread
Un thread est similaire à un processus représentant l’exécution d’un ensemble d’instructions.
7Rapport de stage 2015
Introduction
Dans le cadre de mon Master Systèmes et Microsystèmes Intelligents, parcours Systèmes
Interactifs et Robotique de l’Université Paul Sabatier de Toulouse, j’ai été amené à effectuer un stage
du 7 avril 2015 au 31 juillet 2015 au sein de l’IRIT (Institut de Recherche en Informatique de
Toulouse), plus précisément dans l’équipe SAMoVA.
L’objectif de ce stage est de réaliser une plateforme Web de partage et de traitement de fichiers
audio. Ce stage s’inscrit dans le cadre du projet ANR CIESS qui propose l’analyse et la synthèse
d’enregistrements d’ambiances urbaines. Cette plateforme doit permettre à un utilisateur de
déposer un fichier audio avec des annotations textuelles. Elle doit également intégrer des outils
d’analyse automatique sur le contenu des fichiers, ainsi que des outils de synthèse sonore. Enfin,
l’utilisateur pourra visualiser l’ensemble des fichiers du corpus correspondants à certaines requêtes,
visualiser les résultats des outils d’analyse automatique, écouter et télécharger les enregistrements
de son choix.
Ce présent dossier a pour but de présenter les diverses étapes menant à la réalisation des tâches
demandées et l’environnement dans lequel j’ai effectué mon travail. Ce document a également pour
but de présenter les méthodes et outils mis en place, ainsi que la façon dont je me suis intégré en
respectant les exigences liées au métier.
Dans une première partie, je présente le contexte professionnel dans lequel j’ai évolué. Ensuite,
je présente une brève description des outils d’analyse automatique et de synthèse sonore qu’il m’a
fallu intégrer sur la plateforme Web. Je poursuis avec une description des travaux qu’il m’a été
donné d’effectuer pendant ce stage. Je continue sur les perspectives d’évolution. Pour finir, je
conclue sur ces quatre mois passés à l’IRIT.
Un grand nombre de termes techniques sont employés dans ce rapport. Afin de vous aider à les
comprendre, si cela est nécessaire, un glossaire vous est proposé en tête du dossier.
8Rapport de stage 2015
I. Contexte professionnel
Dans cette partie, je vais rapidement présenter l’IRIT, l’équipe SAMoVA et l’environnement dans
lequel j’ai travaillé durant mon stage.
1) Présentation de l’IRIT
L’Institut de Recherche en Informatique de Toulouse (IRIT2) compte 700 membres (permanents
et non-permanents) et est une des plus importantes Unité Mixte de Recherche en France. L’IRIT se
situe sur le campus de l’Université Paul Sabatier de Toulouse et est dirigé par Michel Daydé depuis
2011.
Depuis 2003, l’IRIT est structuré en 7 thèmes de recherche qui regroupent près de 20 équipes
différentes :
Analyse et synthèse de l’information (4 équipes dont l’équipe SAMoVA)
Indexation et recherche d’informations (2 équipes)
Interaction, Coopération, Adaptation par l’Expérimentation (2 équipes)
Raisonnement et décision (3 équipes)
Modélisation, algorithmes et calcul haute performance (1 équipe)
Architecture, systèmes et réseaux (5 équipes)
Sûreté de développement du logiciel et certification (3 équipes)
Les recherches de l’IRIT s’orientent de manière générale selon 4 axes stratégiques :
Systèmes embarqués critiques
Systèmes sociotechniques ambiants
Systèmes informatiques pour la santé et l’autonomie
Masses de données et calcul
Au-delà du niveau national, l’IRIT est également présent au niveau européen et international,
avec par exemple, le laboratoire européen IREP, la participation au Japenese French Laboratory on
Informatics …
Pour mon stage, je me trouve au sein de l’équipe SAMoVA3 faisant partie du thème Analyse et
synthèse de l’information.
2
www.irit.fr
3
www.irit.fr/recherches/SAMOVA/
9Rapport de stage 2015
2) Présentation de l’équipe SAMoVA
L’équipe SAMoVA (Structuration, Analyse et Modélisation de documents Vidéo et Audio) a été
crée en 2002 et son responsable est Julien Pinquier. L’équipe compte une vingtaine de membres
(permanents et non-permanents).
L’équipe développe des modèles et des outils pour la segmentation automatique de documents
vidéo et audio ainsi que des méthodes d’indexation multimédia robustes. Même si la volonté
affichée de l’équipe est d’aborder conjointement l’audio et la vidéo, de nombreuses études restent
mono média.
Plus précisément, les travaux de recherche se penchent sur les principaux thèmes suivants :
la structuration : la plupart des travaux sur ce sujet visent à étudier la façon dont
l’information dans un signal audio/vidéo est organisé,
l’analyse : l’équipe développe des méthodes et des outils pour créer des nouvelles
fonctionnalités d’extractions et d’exploitations,
la modélisation : pour des tâches de reconnaissance, des objets multimédias (locuteurs,
langages, formes humaines …) doivent être spécifiés à travers un ensemble de paramètres
qui sont prédéfinis par des algorithmes lors d’une phase d’apprentissage.
3) L’environnement de travail
Mon lieu de travail se situe au 118 route de Narbonne, sur le campus Paul Sabatier à Toulouse
au sein de l’IRIT. Je suis installé dans un bureau réunissant l’ensemble des stagiaires. Je travaille seul
la plupart du temps mais il arrive parfois que des membres de l’équipe travaillent avec moi.
Niveau matériel, je dispose d’un ordinateur DELL avec un écran 27’’ avec une distribution Ubuntu
14.04. Durant mon stage, j’ai également utilisé un outil de gestionnaire de version : SVN. Pour les
horaires de travail, ceux-ci n’étaient pas fixe. J’arrivais le matin entre 8h/8h30 et je repartais le soir
entre 16h/16h30 avec 1h de pause le midi.
Nous avions également au minimum une réunion par semaine. Celle-ci réunissait l’ensemble des
stagiaires et des maîtres de stage. Nous présentions notre travail réalisé durant la semaine et le
planning pour la semaine suivante. Il arrivait parfois d’avoir d’autres réunions, avec les partenaires
du projet entre autre ou des membres de l’équipe.
De plus, durant le dernier mois de stage, j’ai été amené à travailler avec un développeur de la
société Audiogaming4 pour intégrer un de leur module sur la plateforme Web. Nous étions donc en
constance relation et nous organisions des réunions chaque semaine pour faire le point sur
l’avancement.
4
http://www.audiogaming.net/
10Rapport de stage 2015
II. Les outils d’analyse automatique
Comme présenté dans l’introduction, mon stage s’inscrit dans le cadre du projet ANR CIESS. Ce
projet vise à créer des méthodes robustes et innovantes pour l’analyse automatique des sons dans
un environnement urbain. Ces méthodes sont basées sur les compétences acquises dans le domaine
de la reconnaissance des sons. Le projet doit permettre d’élaborer une modélisation cohérente et
significative des paysages sonores.
Je vais maintenant présenter les outils d’analyse automatique en lien avec le projet ANR CIESS
que j’ai du intégrer sur la plateforme Web. Dans cette partie, je ne présente pas comment ont été
réalisés ces outils, mais plutôt leurs utilités et fonctionnements. J’explique dans la partie suivante
comment j’ai intégré ces différents outils sur la plateforme Web.
1) Descripteurs de détection de son environnemental
Un environnement urbain est composé d’une multitude de sons. Un auditeur peut en distinguer
et en identifier un nombre important selon ses habitudes et son expertise. Une étude a été réalisée
sur les représentations mentales de ces ambiances. Elle a identifié une quinzaine de sons qui étaient
particulièrement représentatifs des ambiances urbaines [1]. L’équipe a décidé de se concentrer sur 3
types de sons en particulier : les bruits de moteur, de pas et de klaxons.
Après avoir créé des méthodes [2] en langage Python permettant d’identifier ces 3 différents
sons dans un fichier audio, les résultats de ses détections sont enregistrés dans des fichiers textes
appelés descripteurs. Un descripteur est calculé pour chaque type de sons, donc 3 descripteurs au
total pour chaque fichier audio.
Sur la figure 1, nous trouvons un exemple de descripteur pour la détection des sons de moteur
dans un fichier audio. La première colonne correspond au temps en seconde, la seconde colonne
correspond à un indice de confiance (probabilité) pour la détection du son de moteur. Par exemple,
sur ce descripteur, nous pouvons remarquer qu’il n’y a pas de bruit de moteur entre 80,5 et 82,5
secondes. Par contre, des bruits de moteur sont présents à partir de 83 secondes (l’indice de
confiance à 83 secondes est de 0.215, ce qui signifie que nous sommes sûr à 21,5% que le son
détecté est un bruit de moteur).
Figure 1 : Descripteur d’un fichier audio pour les bruits de moteur
11Rapport de stage 2015
Comme nous pouvons le constater sur la figure précédente, nous obtenons des descripteurs
avec d’importantes métadonnées textuelles, ce qui est très fastidieux et long à analyser pour des
fichiers audio d’une très grande durée.
Le TM-Chart [3] est un outil efficace pour représenter ces données sous forme de « graphe »
mais il est très peu utilisé dû à une annotation humaine coûteuse. Ce TM-Chart fournit une
visualisation simple d’un environnement sonore en utilisant les annotations faites manuellement.
Dans le cadre du projet, nous utilisons une nouvelle approche pour calculer automatiquement les
TM-Charts, que nous avons appelé les SamoCharts [4]. Les descripteurs présentés sont utilisés pour
l’affichage des SamoCharts.
2) Les SamoCharts
Les SamoCharts permettent de donner une représentation visuelle des métadonnées et ont été
implantés en JavaScript par Patrice Guyot. Grâce aux SamoCharts, nous sommes capables en un coup
d’œil de connaître les sons présents dans le fichier audio ainsi que leurs proportions.
La figure 3 montre un exemple de 3 SamoCharts pour 3 fichiers audio différents. Les SamoCharts
ci-dessous sont basés sur un score de confiance d’où les différentes teintes de couleurs. La légende
est composé d’une couleur représentant un type de son (le bleu pour les pas, le vert pour les klaxons
et le jaune pour les moteurs). La taille des SamoCharts est légèrement différente dans cet exemple :
en effet, plus le SamoChart est petit, plus la durée du fichier son est courte et au contraire, plus le
SamoChart est grand, plus la durée est importante. Nous utilisons l’équation présentée sur la figure
2 pour calculer la hauteur h du SamoChart en fonction de sa durée d en secondes.
Figure 2 : Equation du calcul de la taille des SamoCharts
Pour chaque SamoChart, nous avons le nom du fichier audio associé. L’axe des abscisses
correspond à la durée du fichier audio. L’axe des ordonnées correspond au pourcentage de chaque
son pour chaque indice de confiance. Par exemple, pour le fichier Ambiance04-16k, nous pouvons
remarquer qu’il y a des bruits de pas et des bruits de moteur. Pour les bruits de pas, nous sommes
sûr à 80% qu’environ 40% du total des bruits de pas sont identifiés comme tel. De même, nous
sommes sûr à 60% qu’environ 20% sont identifiés comme des bruits de pas (idem pour 40% de
confiance).
12Rapport de stage 2015
80%
20%
40%
Figure 3 : SamoCharts basés sur les scores de confiance
Sur le même principe, il existe également des SamoCharts basés sur l’énergie. La figure 4 montre
les SamoCharts de 4 fichiers audio différents. Nous retrouvons l’énergie pour chaque type de son. La
partie « unknown » correspond à tous les autres bruits qui n’ont pas été identifiés comme des sons
de pas, de klaxons ou de moteur.
Figure 4 : SamoCharts basés sur l’énergie
3) Synthèse sonore
Les outils de synthèse sonore ont été réalisés par un partenaire du projet, à savoir la société
Audiogaming. Je suis donc en constante relation avec un développeur de cette entreprise (Benjamin
Levy), pour l’intégration de leurs modules sur la plateforme.
13Rapport de stage 2015
La synthèse sonore a pour but de générer un nouveau fichier audio en rajoutant des sons. Au
moment où j’écris ce rapport, nous sommes en train de tester un module permettant de rajouter des
sons de vent dans un fichier audio. Par la suite, il sera normalement possible de rajouter des sons de
type moteurs et de pluie.
Ce type de module permettra à un utilisateur de « remodeler » totalement le fichier son, afin par
exemple, d’imaginer à quoi ressemblerait cette rue semi-piétonne si plus de bruit de moteurs
étaient présents.
Mon travail consiste à rassembler ces différents outils et à les lier les uns aux autres. En effet,
chaque outil, que je viens de présenter, fonctionne séparément : les descripteurs sont obtenus en
lançant des programmes en « ligne de commande » faisant référence à des fichiers audio ; les
SamoCharts sont affichés sur une page Web en téléchargeant ces descripteurs ; la synthèse sonore
est lancée en ligne de commande.
Mon objectif est d’intégrer ces outils pour qu’ils fonctionnent tous ensemble et cela de manière
interactive à travers la plateforme Web.
14Rapport de stage 2015
III. Plateforme Web
Dans cette partie je vais présenter la plateforme Web que j’ai développée. Je présente dans un
premier temps les outils utilisés pour le développement et la manière dont je me suis formé pour les
prendre en main. Ensuite, je présente la conception de la plateforme Web (fonctionnalités). Je
continue sur le développement du site Web et l’intégration des modules d’analyse automatique
présentés dans la partie précédente. Enfin je termine sur les tests et résultats obtenus.
1) Les outils utilisés
Il existe de nombreux outils pour créer une plateforme Web. Cependant, les outils d’analyse
automatique ont été créés en langage Python. Il fallait donc trouver un outil compatible avec le
langage Python pour faciliter l’intégration des modules. Il m’a été imposé de développer avec le
Framework Django, qui utilise justement ce langage.
L’architecture utilisée par Django est assimilée au modèle MVT. La figure 5 montre le
fonctionnement du modèle MVT. Lorsqu’un utilisateur appelle une page Web, le Framework va se
charger d’exécuter la vue correspondante via des règles de routage URL définies. La vue va récupérer
les données des modèles, le template associé à la vue et va générer un rendu HTML. Une fois la page
générée, le serveur renvoie le résultat au navigateur de l’utilisateur. De plus, Django intègre une base
de données interne pour l’enregistrement des données et une partie admin pour visualiser les
données de la base de données.
Figure 5 : Framework Django modèle MVT
Ne connaissant ni le Framework Django, ni le langage Python, il m’a fallu dans un premier temps
prendre en main ces outils. Les deux premières semaines de mon stage ont donc été consacrées
uniquement à l’apprentissage du langage Python et du fonctionnement de Django. Pour le langage
15Rapport de stage 2015
Python, j’ai suivi un tutoriel sur le site Web OpenClassrooms5. Pour l’apprentissage de Django, j’ai
suivi le tutoriel officiel sur le site Web de Django6. De plus, j’ai utilisé l’IDE PyCharm7 pour travailler
avec le langage Python.
Après avoir pris en main les différents outils, nous nous sommes penchés sur la conception de la
plateforme Web.
2) Conception
La plateforme doit servir de partage, de traitement et de visualisation des fichiers audio ainsi que
de leurs résultats. La conception n’a cessé d’évoluer au fil du projet. Je présente ici la conception de
la plateforme du début du projet jusqu’à sa version finale.
Nous avons dans un premier temps réalisé un maquettage de la plateforme sur papier avec les
principales fonctionnalités suivantes :
Une page d’accueil pour présenter le projet ANR CIESS, les enjeux et objectifs.
Une page qui permettra de déposer un fichier audio en ajoutant des annotations
textuelles et en choisissant la catégorie du fichier (rue piétonne, rue semi-piétonne ou
route). Les outils d’analyse automatique (partie descripteur) sont effectués dès que le
fichier est déposé sur le site.
Une page pour visualiser le corpus (partie SamoCharts) avec une barre de recherche en
fonction de la catégorie.
Une page pour afficher les informations d’un fichier : annotations, catégorie, écoute et
téléchargement du fichier, affichage des SamoCharts correspondant au fichier.
Mettre en place un système de login pour contrôler les utilisateurs qui ont l’autorisation
de pouvoir déposer des fichiers audio.
Une fois cette première conception posée sur papier, je me suis chargé d’implanter ces
fonctionnalités en réalisant une coquille vide de la plateforme, c'est-à-dire en simulant certaines
actions (notamment les outils d’analyse automatique). Nous pouvons voir sur les images ci-dessous
le résultat de cette première conception.
La figure 6 montre la page d’accueil. Le contenu de cette page est tiré du site Web de l’équipe
SAMoVA, qui présente ses projets en cours. Le contenu étant en anglais8, je l’ai traduit en français.
5
http://openclassrooms.com/
6
https://docs.djangoproject.com/fr/1.8/intro/tutorial01/
7
https://www.jetbrains.com/pycharm/
8
http://www.irit.fr/recherches/SAMOVA/pageciess.html
16Rapport de stage 2015
Figure 6 : Conception de la page d’accueil
La figure 7 montre la page de dépôt d’un fichier audio. Nous trouvons un système permettant de
télécharger un fichier, d’ajouter des annotations textuelles concernant le fichier, et de choisir une
catégorie parmi les suivantes (issues du travail du partenaire Octogone) : piétonne, semi-piétonne et
route. L’utilisateur n’a plus qu’à valider le formulaire.
Figure 7 : Conception de la page de dépôt d’un fichier
17Rapport de stage 2015
La figure 8 montre la visualisation du corpus des fichiers déposés. La visualisation est ici très
simple, il y a seulement le nom des fichiers qui ont été déposés et un lien pour naviguer vers leurs
informations. Il est bien entendu prévu d’afficher sur cette page les SamoCharts des fichiers audio.
Nous trouvons également une barre de filtre pour rechercher en fonction de la catégorie.
Figure 8 : Conception de la page de corpus
Enfin, la figure 9 montre la page d’information d’un fichier audio déposé par l’utilisateur. Cette
page est accessible lorsque l’utilisateur clique sur le nom d’un fichier sur la page du corpus. Nous
retrouvons les informations saisies par l’utilisateur lors du dépôt, la date de dépôt, la possibilité
d’écouter et de télécharger le fichier audio. Nous voyons ensuite le SamoChart associé au fichier
audio (ce n’est ici qu’une image en dur, aucun traitement n’a encore été effectué à ce stade).
18Rapport de stage 2015
Figure 9 : Conception de la page d’information d’un fichier
Une fois cette première conception réalisée, nous nous sommes aperçu que certains éléments
manquaient et que d’autres devaient être approfondis.
Dans un premier, la question fût posée quant à la taille de la fenêtre de navigation. Comme nous
pouvons le remarquer sur la figure 8, le site Web est centré dans le navigateur et ne prend pas toute
la taille de l’écran. Nous avons décidé d’augmenter la taille de nos pages (pour pouvoir visualiser plus
de fichiers audio) et d’ajuster celle-ci en fonction de la taille de l’écran.
Sur la page de dépôt d’un fichier, la conception a évoluée de la manière suivante :
Suppression des catégories piétonne, semi-piétonne et route, remplacées par les
catégories suivantes :
o Situation 1 : Rue semi-piétonne en ville entre 12h et 14h, un jour de semaine et il
fait beau,
o Situation 2 : Rue non piétonne en ville sur le trottoir, le matin vers 8h, en
semaine et il fait beau,
o Situation 3 : Même rue que la situation2, il est 21h et il fait beau
o Situation 4 : Autre.
Ajout d’une liste de tags pour que l’utilisateur puisse associer des sons à son fichier
audio.
Ses modifications ont été faites en accord avec les partenaires du projet. En effet, ces situations
et la liste des tags sont issues du protocole expérimental réalisé par les partenaires et l’équipe
SAMoVA. De ce fait, nous avons décidé de rajouter une page expliquant le protocole expérimental
CIESS et une page pour expliquer le principe de la synthèse sonore.
19Rapport de stage 2015
De plus, au vues des informations délivrées par les SamoCharts, nous devions proposer une
méthode permettant d’effectuer des recherches plus ciblées et d’utiliser des méthodes de tri. Nous
avons donc revu le système de recherche sur la page de corpus. Dorénavant, l’utilisateur peut
chercher des fichiers audio en fonction de sa catégorie et/ou ses tags. De plus, l’utilisateur peut
effectuer des tris sur les SamoCharts pour trier en fonction de certains critères (par exemple si
l’utilisateur veut savoir dans quel fichier audio il y a le plus de bruits de moteur). L’utilisateur peut
donc trier de plusieurs manières :
Pas : du plus petit au plus grand nombre de pas,
Pas : du plus grand au plus petit,
Klaxons : du plus petit au plus grand nombre de klaxons,
Klaxons : du plus grand au plus petit,
Moteur : du plus petit au plus grand nombre de bruits de moteur,
Moteur : du plus grand au plus petit.
Nous avons également décidé d’utiliser 2 modes d’affichages sur cette page de corpus : un mode
d’affichage pour afficher les SamoCharts basés sur l’indice de confiance et un autre mode d’affichage
pour afficher les SamoCharts basés sur l’énergie. Sur cette page de corpus, il est également prévu
que l’utilisateur puisse zoomer sur les SamoCharts avec la molette de sa souris.
Une version du site en Anglais est également envisagée pour proposer le contenu du site en 2
langues.
Nous avons rajouté un profil utilisateur pour savoir quels fichiers audio ont été déposés par tel
utilisateur.
De plus, nous avons choisi d’implémenter la partie de synthèse sonore sur la page d’information
d’un fichier audio.
Enfin, nous avons prévu d’afficher le contenu de la plateforme Web en 2 langues (Français et
Anglais) au choix de l’utilisateur.
Une fois toutes ces fonctionnalités établies, je me suis chargé de développer la plateforme Web à
partir de la coquille vide réalisée lors de la conception et d’intégrer les outils d’analyse automatique
présentés plus haut. Je vais maintenant présenter comment a été développé la plateforme et
comment j’ai intégré les différents modules.
3) Développement et intégration des modules d’analyses
Le développement a commencé avec la conception de la coquille vide présentée dans la partie
précédente. Comme dit précédemment, Django utilise le modèle MVT (un exemple de fichier pour
chaque élément est présenté en annexe). Je vais donc tout d’abord présenter la partie Modèle, la
partie Vue, puis la partie Template. J’explique ensuite comment j’ai intégré les différents outils
d’analyses.
20Rapport de stage 2015
i. Modèles
La figure 10 montre les modèles développés pour la plateforme Web. Nous avons un modèle
FILE, qui regroupe les données du fichier audio (son nom, sa date de dépôt, sa description,
l’utilisateur qui a déposé le fichier…). Nous avons ensuite un modèle CATEGORY qui regroupe les
situations présentées dans la conception. Nous avons également un modèle TAG qui regroupe la liste
des tags. Puis un modèle RESULT, qui regroupe notamment les résultats (descripteurs) des fichiers
audio. Enfin, un modèle USER pour permettre à l’utilisateur de se connecter. Les modèles ci-dessous
correspondent au schéma de la base de données (excepté la partie USER qui est utilisée uniquement
pour générer le formulaire de connexion).
Les types de données correspondent aux éléments suivants :
FileField : champ de fichier à déposer,
DateTimeField : champ pour la date et l’heure,
TextField : champ de texte long,
CharField : champ pour une chaîne de caractère,
BooleanField : champ vrai/faux,
ForeignKey : relation de plusieurs à un,
ManyToManyField : relation de plusieurs à plusieurs.
Figure 10 : Modèle de la plateforme Web
Comme la figure 10 le montre, un fichier doit avoir une catégorie et une catégorie peut être
assignée à 0 ou plusieurs fichiers. Un fichier doit également avoir un ou plusieurs tags et un à
plusieurs résultats. Ce modèle a été pensé pour rajouter dynamiquement des catégories et des tags
sans passer par le code, mais en utilisant directement la partie admin (que je présente plus loin dans
21Rapport de stage 2015
ce chapitre) : nous pouvons donc à tout moment rajouter de nouveaux tags ou catégories en
quelques clics. De même, la partie résultat est « extensible » : nous pouvons enregistrer autant de
résultat que nous souhaitons (nous n’avons pas besoin de modifier la partie modèle, si par exemple
nous voulions enregistrer de nouveaux résultats issus de nouveaux outils d’analyses).
ii. Vues
Une vue permet de paramétrer la page Web. Chaque page Web aura donc une vue différente.
Une vue est une fonction ou classe qui prend une requête en paramètre et qui renvoie une réponse
avec des données. Nous avons donc autant de vues que de pages que nous souhaitons générer (au
total, il y a actuellement 9 vues différentes sur le site Web).
De plus, chaque URL du site est associé à une vue, ce qui permet la navigation entre les
différentes pages. Chaque vue est également associée à un template/gabarit. Les informations
récupérées par la vue (via la base de données) vont être transmises au template à travers des
variables de contexte. Celles-ci permettront d’afficher les données.
iii. Templates
Les templates sont de simples fichiers HTML où nous pouvons récupérer et utiliser les variables
de contexte pour afficher des données. Chaque template correspond à une vue. Nous avons au total
7 templates différents (il y a moins de templates que de vues car certains templates sont associés à
plusieurs vues).
iv. Administration
Django permet d’avoir une partie réservée à l’administration sur le site Web qu’il faut configurer
à travers des classes. Sur cette partie administrative, nous pouvons notamment visualiser les
différents modèles ainsi que leurs données. La figure 11 montre les données d’un fichier du modèle
FILE. Sur cet exemple, nous trouvons toutes les informations sur le fichier qui a été déposé :
Emplacement du fichier audio,
Date de dépôt, description,
Catégorie et tags,
Utilisateur qui a déposé le fichier,
Liste des résultats.
22Rapport de stage 2015
Figure 11 : Page administration du modèle FILE
v. Intégration des outils d’analyse automatique
Une fois la mise en place des modèles, des vues et des templates de base terminée, je me suis
concentré sur l’intégration des différents outils d’analyses.
Concernant l’intégration des descripteurs (cf. II.1), celle-ci n’a pas posé de gros problème. J’ai
dans un premier temps pris le temps de changer tous les chemins de configuration pour l’adapter à la
plateforme. Il a fallu ensuite penser au traitement en lui-même. Comme dit dans la partie II, ce
module se lance à partir d’un terminal en ligne de commande avec des paramètres. Il a donc été
modifié pour être appelé dans le Framework. De plus, le traitement doit se faire automatiquement
dès que l’utilisateur a appuyé sur le bouton « valider » du formulaire de dépôt. Pour ne pas gêner le
traitement et pour éviter que l’utilisateur reste bloqué sur la page de dépôt le temps que le
traitement s’exécute, le module est lancé en arrière plan de la plateforme (avec l’utilisation d’un
thread). Ainsi l’utilisateur ne se rend compte de rien et peut continuer à naviguer sur la plateforme
sans interférence avec le traitement. Une fois le traitement terminé, l’utilisateur reçoit un message
sur sa boite mail pour l’informer que son fichier à bien été traité.
L’intégration de la partie SamoCharts (cf. II.2) a pris relativement plus de temps. Comme dit
précédemment, le module d’affichage des SamoCharts est réalisé en JavaScript, donc intégré
directement dans le code HTML. Et comme expliqué en partie II, l’affichage des SamoCharts se faisait
avec le dépôt et la lecture des descripteurs des fichiers audio côté client. Hors ici il ne faut plus
déposer de descripteurs. En effet, les descripteurs doivent être chargés automatiquement par le
programme JavaScript en fonction des descripteurs déjà présent dans la base de données. De même,
23Rapport de stage 2015
la lecture des descripteurs se fait maintenant côté serveur et plus côté client. Il a donc fallu apporter
des modifications pour pouvoir intégrer correctement ce module.
De plus, les SamoCharts basés sur l’énergie possèdent également des descripteurs mais la chaîne
de traitement du calcul des SamoCharts n’avait pas été complètement implémentée. J’ai donc
totalement modifié l’algorithme qui permet de calculer l’énergie pour pouvoir automatiser le
traitement comme le montre la figure 12. A partir des descripteurs basés sur la confiance, nous
récupérons chaque segment de temps où un son a été entendu, ce qui nous donne le premier fichier
à gauche de la figure 12. Par exemple, on remarque que sur un fichier, de 46.592 à 48.832 secondes
nous avons des sons de moteur, de 7 à 11.5 secondes des bruits de pas, … . Cela nous permet de
calculer l’énergie pour chaque type de sons et également sur le reste du fichier audio (représenté par
la partie « unknown »). Nous obtenons ainsi 4 descripteurs (exemple fichier de droite de la figure 12)
pour la partie énergie (3 descripteurs pour les sons et 1 descripteur pour la partie inconnue).
Figure 12 : Calcul des descripteurs pour l’énergie
Enfin, la synthèse sonore (cf. II.3) n’a pas encore été intégrée. Nous avons reçu ce module de la
part d’Audiogaming la semaine du 22 Juin. Au moment où j’écris ce rapport, le module n’a pas
encore pu être testé et intégré au site Web.
Au fur et à mesure du développement et de l’intégration, je testais les parties que j’avais codées.
Je vais maintenant présenter dans la prochaine partie les tests effectués et les résultats obtenus.
24Rapport de stage 2015
4) Tests et résultats
Pour vérifier le bon fonctionnement du programme, j’ai testé chaque module que j’ai
programmé. Je faisais donc des tests très régulièrement. Voici ci-dessous une liste de quelques tests
que j’ai effectués :
Système d’authentification. J’ai tout d’abord vérifié le bon fonctionnement du système
de connexion et de déconnexion. J’ai également fais des tests pour vérifier si la page de
dépôt était bien sécurisée et accessible uniquement lorsque l’utilisateur se connecte.
Formulaire de dépôt d’un fichier. Plusieurs tests ont été effectués pour vérifier le bon
fonctionnement du formulaire. De même il m’a fallu vérifier que les données étaient bien
enregistrées dans la base de données.
Visualisation des données. J’ai vérifié que les SamoCharts étaient affichés correctement
(grâce à l’ancien module).
De nombreux autres tests ont été effectués sur la plateforme (taille du site, navigation, barre de
recherche, filtrage, mode d’affichage, écoute et téléchargement d’un fichier, …).
Je vais maintenant vous présenter la plateforme Web à travers quelques captures d’écrans.
La figure 13 montre la page d’accueil du site. Cette page permet d’informer l’utilisateur sur le
projet CIESS (enjeux, objectifs).
Figure 13 : Page d’accueil
25Rapport de stage 2015
La figure 14 montre la page du protocole expérimental. Nous trouvons une description de tout le
protocole réalisé avec les partenaires.
Figure 14 : Page protocole expérimental
La figure 15 montre le nouveau formulaire de dépôt : l’utilisateur dépose son fichier audio,
peut ajouter des annotations textuelles, une catégorie et un ou plusieurs tags. Tous les champs sont
obligatoires pour pouvoir valider le formulaire. Une fois le formulaire validé, un pop-up apparaît pour
signaler à l’utilisateur que son fichier a bien été pris en compte et qu’il recevra un mail une fois que
son fichier sera traité.
Figure 15 : Page de dépôt d’un fichier audio
26Rapport de stage 2015
La figure 16 montre la visualisation du corpus (en mode d’affichage : SamoChart confiance) :
l’utilisateur a le choix entre 2 modes d’affichage (SamoCharts basés sur la confiance et les
SamoCharts basés sur l’énergie). L’utilisateur visualise l’ensemble des SamoCharts correspondant au
mode d’affichage. Il peut également effectuer des recherches en fonction de la catégorie et/ou les
tags. Il peut trier les SamoCharts en fonction de certains critères (bruit de pas du plus important au
plus petit par exemple). Il peut écouter le fichier audio en cliquant sur son SamoChart. De même un
petit récapitulatif du fichier (catégorie, tags, durée …) apparaît lorsque l’utilisateur passe sa souris sur
le nom du fichier. L’utilisateur a la possibilité de zoomer sur les SamoCharts grâce à la molette de sa
souris. Enfin, il peut consulter le détail du fichier en cliquant sur son nom.
Figure 16 : Visualisation SamoCharts confiance
27Rapport de stage 2015
La figure 17 montre la page de visualisation du corpus en mode SamoCharts basés sur
l’énergie. On retrouve les mêmes fonctionnalités que le mode d’affichage des SamoCharts basés sur
la confiance.
Figure 17 : Visualisation SamoCharts énergie
La figure 18 montre le résultat de quelques recherches et tris sur les SamoCharts basés sur la
confiance.
Figure 18 : Visualisation SamoCharts avec recherche et tri
28Rapport de stage 2015
La figure 19 montre la page d’information d’un fichier. Nous trouvons notamment une balise
audio pour écouter le fichier, sa date de dépôt, sa catégorie, ses tags, sa description, l’utilisateur qui
a déposé le fichier et les SamoCharts correspondant.
Figure 19 : Page de détail d’un fichier audio
La figure 20 montre le profil utilisateur : tous les SamoCharts des fichiers audio déposés sont
affichés pour l’utilisateur X. Nous pouvons visualiser les SamoCharts selon 2 modes d’affichage
comme sur le corpus.
Figure 20 : Profil utilisateur
29Rapport de stage 2015
IV. Travail restant
Comme dit précédemment, il manque encore le module de synthèse à intégrer. Celui-ci devrait
apparaître sur la page d’information d’un fichier. Une pré-écoute du nouveau fichier avec les ajouts
de sons sera disponible. Sur le module du vent, l’utilisateur pourra choisir la force du vent par le bais
d’une scroll bar.
De plus, il reste également à « traduire » le site en Anglais pour proposer le contenu du site en 2
langues.
Pour terminer, il faudra effectuer le déploiement du site pour le rendre public.
30Rapport de stage 2015
Conclusion
Durant ce stage, j’ai proposé une plateforme Web qui n’a cessé d’évoluer, proposant de
nombreuses fonctionnalités (profil utilisateur, formulaire de dépôt, possibilité de trier les résultats,
visualisation du corpus…). Ce travail permettra de mettre en avant les outils d’analyse automatique
créés par l’équipe SAMoVA et les outils de synthèse de la société Audiogaming. La plateforme Web
deviendra ainsi la vitrine du projet ANR CIESS. Cette plateforme va encore évoluer après mon départ.
De nouvelles fonctionnalités vont être ajoutées (synthèse sonore pour les sons de moteur et de pluie
si je n’ai pas le temps de les implémenter, visualisation du vent et la pluie sur les SamoCharts…).
Sur le plan technique j’ai beaucoup appris grâce à ce stage. En effet, je me suis beaucoup
débrouiller par moi-même, notamment les 2 premières semaines pour m’auto-former sur les outils
que j’allais utiliser. De plus, je suis resté très autonome sur tout le reste du stage.
J’ai appris où chercher et comment chercher l’information sans m’éparpiller. Il est également
à noter l’importance de chercher en anglais, le nombre de sources sérieuses et efficaces étant
souvent plus conséquentes qu’en français.
Du point de vue des langages informatiques, j’ai complété mes compétences en
développement Web, avec l’apprentissage du Framework Django et du langage Python. J’ai
également pu approfondir le langage JavaScript, et découvrir le dessin vectoriel (svg). Mes années
antérieures m’ont apportées des bases solides en programmation, j’ai su réutiliser les notions
acquises et cet aspect-là ne m’a pas posé de difficultés particulières.
La confrontation aux divers problèmes rencontrés lors de ce stage ainsi que leurs résolutions
m’ont également apporté une bonne expérience et un enrichissement conséquent sur la gestion de
projet.
D’un point de vue humain, cette expérience m’a beaucoup apporté. Je pense que l’on peut
qualifier mon intégration de réussie. Il a été extrêmement enrichissant de découvrir les recherches
de l’équipe SAMoVA. J’ai eu la chance de participer à beaucoup de réunions. En effet, outre les
réunions stagiaires qui se déroulaient chaque semaine, j’ai participé à plusieurs réunions avec les
partenaires du projet. Cela m’a permis de me rendre compte à quel point la communication et le
travail d’équipe est important. De plus, un séminaire a été organisé au mois de Juin. J’ai du présenter
mon travail à l’équipe et vice-versa, cela de manière conviviale. Toutes ses réunions restent pour moi
un point très positif durant ce stage.
A l’issue de ce stage, je ne sais toujours pas si je vais continuer sur une thèse. J’ai découvert
le monde de la recherche et je dois avouer que ce milieu est très attirant de part les projets qui sont
réalisés. Il me reste encore une année à effectuer, j’ai donc encore le temps de réfléchir…
Ce stage est ma deuxième expérience professionnelle dans le monde de l’informatique et je
suis ravi de l’avoir effectué à l’IRIT. J’en garderai un très bon souvenir et en ressortirai avec de solides
compétences en plus.
31Rapport de stage 2015
Références
[1] Cynthia Magnen, Julien Tardieu, Pascal Gaillard. A method to collect representative samples of
urban soundscapes. Dans: European Congress and Exposition on Noise Control Engineering
(EURONOISE 2015), Maastricht, 31/05/2015-03/06/2015, mai 2015.
[2] Patrice Guyot, Julien Pinquier. Soundscape visualization: a new approach based on automatic
annotation and Samocharts (regular paper). Dans: European Congress and Exposition on Noise
Control Engineering (EURONOISE 2015), Maastricht, 31/05/2015-03/06/2015, mai 2015.
[3] K. Hiramatsu, T. Matsui, S. Furukawa, and I. Uchiyama. The physcial expression of sound-scape: An
investigation by means of time component matrix chart. Dans: INTER-NOISE and NOISE-CON Congress
and Conference Proceedings, vol. 2008, no. 5. Institute of Noise Control Engineering, 2008, pp. 4231–
4236.
[4] Patrice Guyot, Julien Pinquier. Browsing soundscapes (regular paper). Dans: International
Conference on Technologies for Music Notation and Representation (TENOR 2015), Paris,
28/05/2015-30/05/2015, mai 2015.
32Rapport de stage 2015
Annexes
Le code ci-dessous montre un exemple de l’implémentation des modèles File et Result.
# -*- coding: utf-8 -*-
from django.db import models
from django.contrib.auth.models import User
class File(models.Model):
"""
Model pour un fichier audio, contient:
le nom du fichier audio (avec son chemin de localisation)
la date d'upload
la description
la situation
un ou plusieurs tags
le nom de l'utilisateur qui a uploader le fichier
un boolean pour savoir si le calcul des SamoCharts est fini
"""
fichier_audio =
models.FileField(upload_to='plateform/static/media/media/')
date_fichier = models.DateTimeField('date')
description_fichier = models.TextField(null=True)
user = models.ForeignKey(User, default='')
categorie = models.ForeignKey(Categorie)
tag = models.ManyToManyField(Tag)
active = models.BooleanField(default=0)
class Result(models.Model):
"""
Model pour enregistrer les resultats
Chaque resultat correspond à un fichier
On enregistre le chemin ou se trouve le fichier resultat et le type de
resultat
"""
file = models.ForeignKey(File, default='')
chemin_fichier = models.CharField(max_length=250, default='')
type_result = models.CharField(max_length=250, default='')
def __str__(self):
return self.chemin_fichier
33Rapport de stage 2015
Le code ci-dessous montre l’implémentation de la vue du corpus et du détail d’un fichier
audio.
# -*- coding: utf-8 -*-
def file_view(request):
"""
Vue pour la page du corpus
Si l'utilisateur fait une recherche, recupère le resultat de la
recherche dans la variable query
Sinon, affiche de nouveau de formulaire de recherche, et par default
les SamoCharts de tous les fichiers dans la BDD
(triés pas date du plus récent au plus ancien)
Utilise le template file.html
"""
if request.method == 'POST':
form = CategoryForm(request.POST)
if form.is_valid():
category = form.cleaned_data['categorie']
tag = form.cleaned_data['tag']
sort_option = form.cleaned_data['sort_option']
view_samochart = form.cleaned_data['view_samochart']
if category:
if tag:
query =
File.objects.filter(categorie__categorie_fichier__contains=category,
tag__in=tag).order_by('-
date_fichier')
query.query.group_by = ["fichier_audio"]
else:
query =
File.objects.filter(categorie__categorie_fichier__contains=category).order_
by('-date_fichier')
elif tag:
query = File.objects.filter(tag__in=tag).order_by('-
date_fichier')
query.query.group_by = ["fichier_audio"]
else:
query =
File.objects.filter(date_fichier__lte=timezone.now()).order_by('-
date_fichier')
return render(request, 'plateform/file.html', {'form': form,
'query': query, 'sort_option': sort_option,
'view_samochart': view_samochart})
else:
form = CategoryForm()
query =
File.objects.filter(date_fichier__lte=timezone.now()).order_by('-
date_fichier')
return render(request, 'plateform/file.html', {'form': form, 'query':
query})
34Rapport de stage 2015
class DetailFileView(generic.DetailView):
"""
Vue générique pour afficher le détail d'un fichier audio
Utilise le model d'un fichier
Utilise le template detail.html
"""
model = File
template_name = 'plateform/detail.html'
def get_queryset(self):
return File.objects.filter(date_fichier__lte=timezone.now())
Enfin, le code ci-dessous montre une partie de l’implémentation du template de la page de
détail d’un fichier audio.
{% load staticfiles %}
...
...
...
...
{{
file.fichier_audio|cut:"plateform/static/media/media/" }}
DATE:
{{ file.date_fichier|date:"d-m-Y"
}}
CATEGORIE:
{{ file.categorie }}
TAGS:
{{
file.tag.all|cut:"[" |cut:"]" |cut:"" | cut:"Tag:" }}
35Rapport de stage 2015
DESCRIPTION:
{{
file.description_fichier|capfirst }}
{{ file.user }}
Support
Partenaires
Contact
ciess-webmaster@irit.fr
...
...
...
36Vous pouvez aussi lire
