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
IV. Le KSR ................................................................................................. 8
V. Structure ............................................................................................. 10
1/10
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/10
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/10
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/10
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/10
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/10
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/10
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 ».
Les poids sur chaque lettre sont calculés automatiquement à partir
dictionnaire. A chaque lettre entrée, on va chercher dans le dictionnaire la probabilité
des lettres suivantes. Ainsi les mots les plus probables seront proposés à l’utilisateur.
Dans un premier temps, on calculera les probabilités uniquement à partir du
dictionnaire. Après quelques temps d’utilisation, on pourra modifier ces probabilités
en fonction des mots les plus souvent entrés par l’utilisateur.
IV. Le KSR
Après chaque saisie d’un caractère, une liste de prédictions lexicales est
présentée à l’écran. Si l’utilisateur retient une de ces propositions, le texte est
automatiquement complété, ce qui évite la saisie des dernières lettres du mot.
L’efficacité des systèmes de prédiction est évaluée par le taux d’économie de saisies,
suivant une métrique appelée KSR (keystroke saving rate) :
KSR = (1 - K°/K) x100
Avec K° le nombre de d’appuis sur le dispositif d’entrée et K le nombre de
lettres totales de la chaîne a entrer.
Par exemple pour taper le mot « voiture », l’utilisateur va entrer les lettres du
mot au fur et à mesure : v . o . i . t …
Si le système propose à l’utilisateur le mot voiture au bout de la 5ème lettre
tapée (« voitu »), on aura alors gagné 2 lettres. Le KSR seras :
KSR (voiture) = (1 – 5/7) x 100 = 28.6
8/10
Projet SYBILIUM
Pour le mot voiture, le KSR seras donc de 28.6%. Le but du KSR est donc de
calculer les performances d’un moteur de prédiction. Il correspond au nombre de
lettres gagnées lors de la frappe.
Dans le cas de la prédiction en N-Grammes, le KSR peut aussi servir à calculer
le nombre de mots gagnés. Par exemple pour écrire I« le petit chat », on tape « le
peti» et le moteur va nous proposer directement la phrase que l’on souhaitait. Le
KSR seras donc de 45% environ.
Un des buts premier de notre moteur de prédiction est la performance, nous
utiliserons donc le KSR pour comparer les performances obtenues avec différents
moteurs. Notre objectif est d’avoir un KSR d’au moins 60%.
9/10
Projet SYBILIUM
V. Structure
Un noeud est composé d’un caractère, d’un poids, et d’une liste de nœuds qui
représente la liste de ses fils.
typedef struct s_noeud
{
char info;
float poid;
list noeud;
} t_noeud;
A chaque nœud on attribue une liste de nœuds qui représente la liste de ses
fils. Cette liste de nœuds est modélisée selon la structure suivante : un pointeur sur
un nœud, et un pointeur sur la liste suivante des fils.
typedef struct s_noeud * tree;
typedef struct s_list * list;
typedef struct s_list
{
tree valeur;
list suiv;
} slist ;
Pour lancer le remplissage de l’arbre à partir du dictionnaire, on commence
par lancer le timer. Ensuite on appelle la fonction qui va remplir l’arbre, puis on
affiche le temps mis par le remplissage.
/* Incrémentation du timer */
clock_t start, end;
start = clock ();
/* on remplit l’arbre à partir du dictionnaire */
t_noeud * racine = (t_noeud *)remplirArbre("fr350k.dic");
/* fin du timer */
end = clock ();
/* affichage du timer */
printf("Temps en secondes : %f\n",(end - start) / (double)CLOCKS_PER_SEC);
system("pause");
return 0;
10/10