I.1. Sybilium

Projet SYBILIUM
Sybiliuuuuuuuuuuuuuuuuuuuuuuuuum !!!!!!!
Table des matières :
I. Présentation du projet ............................................................................. 2
I.1. Sybilium ........................................................................................... 2
I.2. Contraintes du projet ........................................................................ 3
I.2.a. Programmation ........................................................................... 3
I.2.b. Performances ............................................................................. 3
II. Moteur de prédiction .............................................................................. 4
I.3. Les différentes étapes ....................................................................... 4
I.3.a. Mots .......................................................................................... 4
I.3.b. N-Gram ...................................................................................... 4
III. Arbres .................................................................................................. 6
I.4. Définition.......................................................................................... 6
I.5. Arbre pondéré .................................................................................. 7
I.6. Application à Sybilium ....................................................................... 7
1/8
Projet SYBILIUM
I. Présentation du projet
I.1. Sybilium
Nom du projet
Type d’application
Encadrement
Nombre d’étudiants
Etudiants
Sybilium
Moteur de prédiction pour aide au handicap
Yannick Estève
5
BOULIERE Julien
BRICHET Gaëtan
CERDAN Yohann
MOULIN Julien
VIALLEFONT Gregory
Le projet Sybilium est un projet axé principalement sur l’aide au handicap.
Le projet Sybilium consiste à développer un moteur de prédiction de mots et à
l’intégrer au logiciel Sybille : ce logiciel est un logiciel développé pour la saisie de
mots par des personnes qui ne peuvent utiliser un clavier classique en raison de leur
handicap. Ceci permet aux personnes fortement handicapées de pouvoir rédiger des
documents électroniques.
Le processus de saisie utilisé dans Sybille consiste à faire défiler un curseur
sur chaque lettre de l’alphabet, l’utilisateur envoyant une impulsion (par un
mouvement de paupière, d’un doigt, etc.) lorsque le curseur se superpose au
caractère qu’il souhaite afficher.
Sybille possède également un moteur de prédiction qui permet d’accélérer le
processus de saisie en intégrant un système de complétion qui propose à l’utilisateur
les mots les plus probables en fonction des lettres déjà saisies.
L’image suivante représente une capture d’écran du logiciel Sybille :
2/8
Projet SYBILIUM
En raison des compétences du LIUM dans le domaine de la reconnaissance de
la parole, il a été proposé au LIUM de participer à l’amélioration du moteur de
prédiction. En effet, ce type de problématique est très proche de certaines
problématiques rencontrées en reconnaissance de la parole.
Pour cela, le LIUM a besoin de son propre moteur de prédiction de mots. Ce
moteur doit s’intégrer aux outils du LIUM déjà existants, et devra pouvoir interagir
avec le logiciel Sybille : c’est l’objectif du projet Sybilium.
I.2. Contraintes du projet
I.2.a. Programmation
Sybille est développé en .NET (Sybille n’est pas un logiciel libre). Le moteur de
prédiction devra fonctionner aussi bien sous linux/UNIX que sur une plateforme .NET
intégré au logiciel Sybille. Pour des raisons de performances, Sybilium sera
développé en langage C.
I.2.b. Performances
Sybilium doit pouvoir proposer des mots à l’utilisateur en temps réel, le temps
de réponse après chaque requête de l’utilisateur doit être réduit au maximum. C’est
pour cette raison que le langage choisit fut langage C.
3/8
Projet SYBILIUM
II. Moteur de prédiction
I.3. Les différentes étapes
I.3.a. Mots
L’objectif principal de Sybilium est la prédiction de mots. Le principe est de
deviner le mot que l’utilisateur veut taper à partir des premières lettres, et ainsi
diminuer le nombre d’action de l’utilisateur.
A chaque lettre tapée par l’utilisateur, Sybilium va lui proposer un certain
nombre de mots possible en fonction des lettres déjà tapées.
Par exemple si l’utilisateur veut taper « allemand », il commence par taper
« a ». Le programme va lui proposer les premiers mots du dictionnaires commençant
par « a ». Plus l’utilisateur va taper de lettres, plus les mots proposés vont se
rapprocher de ce qu’il veut taper. Lorsqu’il sera arrivé à « all », Sybilium va lui
proposer « allemand ». On aura donc gagné plusieurs clicks.
Exemple :
Lettres tapées
a
al
all
Propositions
absent, absolu, absurde, abordable…
albanais, aliment, alimentaire…
allemagne, allemand, allemande…
Dans un premier temps, Sybilium proposeras des mots dans l’ordre
alphabétique du dictionnaire de manière équiprobable. Mais après un certain temps
d’utilisation, Sybilium proposeras des mots en fonction des habitudes de l’utilisateur.
I.3.b. N-Gram
Un n-gramme est une sous-séquence de n éléments construite à partir d'une
séquence donnée. L'idée semble provenir des travaux de Claude Shannon en théorie
de l'information. Son idée était que, à partir d'une séquence de lettres donnée (par
exemple "par exemple") il est possible d'obtenir la fonction de vraisemblance de
l'apparition de la lettre suivante. À partir d'un corpus d'apprentissage, il est facile de
construire une distribution de probabilité pour la prochaine lettre avec un historique
de taille n.
À partir du (court) corpus "par exemple", nous obtenons :
4/8
Projet SYBILIUM
- Pas d'historique (unigramme) :
 p : 2 occurrences sur 10 lettres = 1/5
 e : 3 occurrences sur 10 lettres = 3/10
 x : 1 occurrence sur 10 lettres = 1/10
... La somme des probabilités étant nécessairement égale à 1.0.
- Historique de taille 1 (on considère la lettre et un successeur) :
 p-a : 1 occurrence sur 9 couples = 1/9 ;
 p-l : 1 occurrence sur 9 couples = 1/9 ;
 p-e : 0 occurrence sur 9 couples = 0 ;
... La somme des probabilités étant toujours nécessairement égale à 1.0.
Nous obtenons des probabilités conditionnelles nous permettant de connaître,
à partir d'une sous-séquence, la probabilité de la sous-séquence suivante. Dans notre
exemple, P(a | p) = 1 / 9 est la probabilité d'apparition de l'élément a sachant que
l'élément p est apparu.
À titre d'exemple, le bi-gramme le plus fréquent de la langue française est
« de », comme dans l'article « de », mais aussi comme dans les mots « demain »,
« monde » ou « moderne ».
Ici, nous utiliserons le modèle de prédiction N-Gram Pour des mots et non pas
pour des lettres. Ainsi, nous allons prédire un mot à partir des n-1 mots précédents.
Théoriquement, c’est la probabilité contextuelle d’apparition d’un mot en fonction des
n-1 précédents.
Par exemple, dans le cas d’une prédiction Tri-Gram (3 mots), si l’utilisateur
tape « le poisson », Sybilium va proposer « rouge ».
Dans le cas d’une prédiction N-Gram, Sybilium va proposer à l’utilisateur un
mot a partir des n-1 mots précédents. Pour cela le moteur se servira de ce qu’il aura
appris des habitudes de l’utilisateur.
5/8
Projet SYBILIUM
III. Arbres
I.4. Définition
Un arbre est une structure de donnée récursive générale, représentant un
arbre au sens mathématique. C’est un cas particulier de graphe qui n’a qu’une seule
source et aucun cycle.
Dans un arbre on distingue deux grandes catégories d’éléments :
 les feuilles, éléments ne possédant pas de fils dans l’arbre ;
 les nœuds, éléments possédant des fils (sous-branches).
La racine de l’arbre est le nœud ne possédant pas de parents. La hauteur
d’un arbre est la longueur du plus grand chemin de la racine à une feuille.
Chaque nœud possède une étiquette, qui est en quelque sorte le « contenu »
de l'arbre. L'étiquette peut être très simple: un nombre entier, par exemple. Elle peut
également être aussi complexe que l'on veut : un objet, une instance d'une structure
de données, un pointeur, etc. Il est presque toujours obligatoire de pouvoir comparer
les étiquettes selon une relation d'ordre total, afin d'implanter les algorithmes sur les
arbres.
Par exemple, les répertoires sous la plupart des systèmes d'exploitation
actuels (Microsoft Windows, Unix dont Linux et Mac OS X ...) forment un arbre.
Les arbres sont en fait rarement utilisés en tant que tels, mais de nombreux
types d'arbres avec une structure plus restrictive existent et sont couramment utilisés
en algorithmique, notamment pour gérer des bases de données.
Pour construire un arbre à partir de cases ne contenant que des informations,
on procède généralement ainsi :
 Créer une structure de données composée de :
- l'étiquette (la valeur contenue dans le nœud),
- un lien vers chacun des nœuds fils,
- un arbre particulier, l'arbre vide, qui permettra de caractériser les feuilles :
une feuille a pour fils des arbres vides uniquement.
On peut également procéder comme suit :
 Créer une structure de données composée de :
- l'étiquette (la valeur contenue dans le nœud),
6/8
Projet SYBILIUM
- un lien vers le nœud fils,
- un autre lien vers le nœud frère.
Une autre manière est de disposer de :
 Une structure de données composée de :
- l'étiquette (la valeur contenue dans le nœud),
- un lien vers le nœud père.
On note qu'il existe d'autres types de représentation propres à des cas
particuliers d'arbres. Par exemple, le tas est représenté par un tableau d'étiquettes.
I.5. Arbre pondéré
Dans un arbre « classique » non pondéré, chaque branche a le même
« poids », c’est-à-dire que tous les fils ont la même probabilité.
Dans le cas d’un arbre pondéré, chaque branche a un poids, ce qui
correspond a sa probabilité.
En voici un exemple :
I.6. Application à Sybilium
Pour deviner les mots, on va utiliser une structure en arbre N-aire. A chaque
lettre tapée, il y aura 26 lettres possibles, ainsi que les caractères spéciaux et la
ponctuation. Pour taper le mot « abus » par exemple, l’arbre ressemblera à ceci :
7/8
Projet SYBILIUM
a
a (0.02)
a (0.01) b (0.2)
b (0.4)
…
a (0.1)
…
a (0.01)
c (0.1)
u (0.2)
…
…
a (0.2)
s (0.2)
…
…
z (0.05)
…
Cet arbre est pondéré, les poids affichés sur les nœuds sont les probabilités de
chaque branche. Par exemple lorsque l’utilisateur tape « a », on a 40% de chance
que la prochaine lettre soit un « b », et 10% que se soit un « c ».
8/8