Utilisation du langage Python et de son écosystème dans le

Rapport de veille
Utilisation du langage de programmation Python et de son
écosystème dans le domaine de la science
Une étude de cas pour la recherche dans le domaine de la
reconnaissance de la parole
Première version
Frédéric Osterrath
Agent de recherche senior
Reconnaissance de la parole
Le 21 mai 2013
Partenaire financier :

Rapport de veille
Utilisation du langage de programmation Python et de son écosystème dans le domaine de la science
Une étude de cas pour la recherche dans le domaine de la reconnaissance de la parole
Tous droits réservés  2013 CRIM Le 21 mai 2013
Page 2
TABLE DES MATIÈRES
TABLE DES MATIÈRES ............................................................................................. 2
1.PROBLEMATIQUE .............................................................................................. 3
2.REVISION DES CARACTERISTIQUES DU LANGAGE PYTHON ............................................ 4
3.OUTILS D’INTEGRATION ET D’EXTENSION ................................................................ 6
4.REVISION DE L’ECOSYSTEME SCIENTIFIQUE DE PYTHON .............................................. 7
4.1La pile Scipy ............................................................................................ 7
4.2Routines numériques optimisées .................................................................. 8
4.3Installation de la pile Scipy .......................................................................... 8
4.4Comparaison avec MATLAB .......................................................................... 9
4.5IPython comme environnement d’expérimentation ......................................... 10
5.CONCLUSION ................................................................................................. 12
GLOSSAIRE......................................................................................................... 13
ANNEXE ............................................................................................................ 14

Rapport de veille
Utilisation du langage de programmation Python et de son écosystème dans le domaine de la science
Une étude de cas pour la recherche dans le domaine de la reconnaissance de la parole
Tous droits réservés  2013 CRIM Le 21 mai 2013
Page 3
1. PROBLÉMATIQUE
La validation des hypothèses et des concepts en recherche passe souvent par
l’implémentation d’algorithmes permettant de conclure sur l’efficacité d’une méthode
en observant ses effets sur des données expérimentales. Le chercheur passera donc
beaucoup de temps à programmer tout en modifiant continuellement les processus
développés, même si l’implémentation elle-même n’est pas le but premier de son
travail. Ses outils se doivent donc d’être flexibles et agiles.
Le traitement de la parole est une tâche intensive qui demande une efficacité des
programmes en exécution. Ainsi, les systèmes de traitement de la parole ont été
traditionnellement implémentés en utilisant des langages permettant une bonne
optimisation de l’utilisation des ressources système. Conséquemment, le C ou même le
C++ ont été et demeurent des langages très populaires en reconnaissance de la parole.
Il y a donc un large patrimoine de solutions informatiques que les chercheurs
voudraient réutiliser sans avoir à les programmer à nouveau suivant l’avènement de
nouvelles approches algorithmiques ou même de nouveaux paradigmes d’exploitation
(e.g. :SaaS).
Or, dans la perspective du travail expérimental d’un chercheur, les langages compilés
et statiquement typés tels que le C/C++ ne se prêtent pas toujours aussi bien aux
exigences de flexibilité du travail expérimental que les langages dits de « scripts » tels
que Perl, BASH/CSH, etc. C’est pour cela que bon nombre de solutions de
reconnaissance de la parole utilisées dans la recherche (Kaldi, CMU Sphinx) sont en fait
un assemblage de langages compilés et interprétés. Les logiciels compilés sont
typiquement encapsulés en tant que processus distincts par des scripts permettant une
exploration facile des variantes algorithmiques, mais cela amène un bon nombre de
désavantages et contraintes logicielles causées par ce découplage. Citons par exemple
la nécessité, souhaitable ou non, de passer par des données transitoires dans des
formats et interfaces variés causant une explosion des types. Par ailleurs, les
traitements numériques ou statistiques sont souvent réalisés avec des langages tels que
Fortran, MATLAB ou R, en raison de leur expressivité pour ces tâches, ajoutant une
autre base de code.
Finalement, mentionnons la tendance lourde de la diminution du prix de la vitesse de
calcul et l’augmentation du coût de la main d’œuvre spécialisée en recherche. Si à une
époque il était beaucoup plus dispendieux de mettre la main sur des processeurs très
rapides, on peut dire que cela est une considération contemporaine moins importante
avec la prolifération des solutions de grappes de calcul et d’infonuagique plus
facilement accessibles. Or, l’exploitation de ces solutions se doit d’être standardisée
et facile. Ainsi, il devient généralement plus important pour un gestionnaire de
recherche d’optimiser le temps de développement d’une solution et de valoriser une
polyvalence future, garante d’une plus grande valeur patrimoniale, plutôt que
d’optimiser le temps d’exécution de cette même solution, sans dire pour autant que
cela n’a plus d’importance.
Tous les éléments mentionnés ci-haut posent un certain nombre de dilemmes dans les
choix technologiques des chercheurs et il y a des approches diverses pour tenter de
répondre aux priorités les plus pressantes de chacun. Or, chaque approche apporte son
lot d’avantages et d’inconvénients et il devient parfois difficile à accorder l’une avec

Rapport de veille
Utilisation du langage de programmation Python et de son écosystème dans le domaine de la science
Une étude de cas pour la recherche dans le domaine de la reconnaissance de la parole
Tous droits réservés  2013 CRIM Le 21 mai 2013
Page 4
l’autre. Plus précisément, l’éventail des technologies informatiques qu’une équipe de
recherche doit maîtriser pour mener à terme son travail semble être en perpétuelle
expansion. Dans un tel scénario, il apparaît donc le désir chez plusieurs chercheurs de
recentrer les technologies nécessaires vers un noyau commun couvrant les besoins d’un
plus grand nombre de tâches dans le souhait de se concentrer d’avantage sur le sujet
de recherche que sur les outils employés.
C'est dans ce contexte que nous allons regarder l’utilisation du langage de
programmation Python. L’utilisation de Python dans le domaine de la science est en
nette croissance depuis la parution de la version 2.0 du langage, soit vers l’an 2000. De
nombreuses librairies vouées au traitement scientifique et numérique en plus d’outils
de tout genre et ont été adoptés par un bon nombre de laboratoires de recherches
prestigieux (CERN, Google, Nasa, etc.). Des conférences telles que EuroSciPy et
PyData, entre autres, sur l’utilisation de Python en science et en traitement des
données ont vu le jour, confirmant la tendance. De plus, mentionnons que la
conférence généraliste PyCon aura lieu à Montréal en 2014 et en 2015.
Nous présentons dans ce document une révision des propriétés et tendances courantes
dans l’utilisation de Python dans le domaine de la science, ainsi que quelques
comparaisons avec des solutions comparables offrant ainsi un débroussaillage des
éléments intéressants qui pourraient s’avérer utiles pour autrui. Ce document est
accompagné d’un autre rapport sur les capacités de parallélisation de Python ainsi
qu’un autre sur la solution de stockage des données que propose PyTables.
2. RÉVISION DES CARACTÉRISTIQUES DU LANGAGE PYTHON
Python est un langage de programmation général, multi-paradigmes, dynamiquement
typé et est interprété à l’exécution. Il s’agit d’une solution logiciel libre dotée d’une
licence permettant l’exploitation commerciale sans restrictions.
Dans Python, tout est un objet et toutes les opérations sur les objets s’effectuent par
une référence sur l’objet en question, sauf dans quelques rares exceptions. Le typage
dynamique des objets ne permet généralement pas la translittération des types à
l’exécution, sauf dans le cas d’opérations, mathématiques ou autres, qui auraient du
sens.
Le typage dynamique offre des avantages au niveau du temps de développement et de
la flexibilité du code produit. Par exemple, le cas suivant nécessiterait
considérablement plus de lignes de code en C/C++ ou en Java :
def square ( a ) :
return a * a
>>> square( 9 )
81
>>> square( (3+5j) ) # Fonctionne également avec un nombre complexe, des
fractions, matrices, etc.
(0.90704544951604504-0.70300197182731272j)

Rapport de veille
Utilisation du langage de programmation Python et de son écosystème dans le domaine de la science
Une étude de cas pour la recherche dans le domaine de la reconnaissance de la parole
Tous droits réservés  2013 CRIM Le 21 mai 2013
Page 5
Tout fichier source contenant du code Python est désigné comme étant un « module ».
Le langage inclut le concept des « namespaces » qui compartimente le contexte des
objets tels que les variables, instances de classes ainsi que les fonctions. Ainsi, un
fichier source Python, qu’il implémente un script (approche similaire à du Bash/Perl),
une classe (approche similaire à Java), une collection de fonctions (librairie, tel qu'on
pourrait le voir en C), des paramètres de configuration (similairement à un fichier INI
ou YAML) est un module compartimenté par la logique des namespaces propre au
langage et facilitant sa réutilisation sans pour autant nécessiter l’adoption d’un
quelconque paradigme de programmation ou de travail additionnel. Cette utilisation
des namespaces se différencie de l’utilisation qui en est faite en C++ où son utilisation
est facultative et n’est pas forcément compartimentée par chacun des fichiers sources,
classes, etc.
La librairie standard de Python est souvent citée comme l’un de ses principaux
avantages. Il y a en effet un grand nombre de modules qui sont livrés avec
l’interpréteur. L’expression anglaise souvent employée « batteries included » vise à
illustrer l’idée qu’une installation Python est relativement complète et auto-suffisante.
Citons les exemples suivants parmi les modules de la librairie standard :
 Gestion de communications interprocessus (asynchrones, ssl, RPC, HTTP).
 Gestion de collections (ensembles).
 Persistance et sérialisation des données.
 Débogueur intégré avec outils de profilage.
 Outils de développement d’IHM.
 Expressions régulières, compression, services de cryptographie, etc.
Les librairies disponibles pour les programmeurs, ainsi que la documentation complète
qui y est associée, accélèrent le développement d’applications et facilitent le partage
de code. Lequel sera inévitablement plus concis et compréhensible vu l’universalité de
la librairie standard.
La console Python est un outil fréquemment utilisé d’une manière analogue à CSH ou
BASH. C’est-à-dire que de nombreux développeurs exécutent et développent leurs
programmes directement à l’intérieur d’une console, contrairement à Perl ou tout
autre langage compilé où des programmes seraient lancés suivant l’édition. Cette
approche d’interaction directe avec un programme en exécution, propre à Python,
facilite le débogage ainsi que certaines approches exploratoires comme l’introspection
d’objets ou l’interaction avec les données. Une telle approche est compatible avec les
exigences de la recherche. Nous verrons plus loin des environnements de travail qui
facilitent d’avantage cette approche exploratoire.
L’interpréteur a été porté sur toutes les grandes plateformes (Windows, OSX, UNIX,
Android, etc.) et le code produit par le programmeur est habituellement distribué en
code source (approche typique du logiciel libre) ou en bytecode, de manière analogue
aux fichiers .class de Java qui sont exécutés sur une machine virtuelle propre au
langage.