Transcript Introduction à l'informatique linguistique Mathieu Constant, Eric Laporte Licence d'informatique 3

Introduction à l'informatique
linguistique
Mathieu Constant, Eric Laporte
Licence d'informatique 3
Université de Marne-la-Vallée
IGM
Cours 1
Introduction
Tokenisation
Expressions rationnelles et automates finis
Introduction au langage Python
Introduction
Objectifs de l'informatique linguistique
Applications informatiques sur les langues naturelles
Génération de textes en langues naturelles (écrits, oraux)
Dialogue homme-machine (écrit, oral)
Traduction (écrit, oral)
Recherche d'information, moteurs de recherche
Extraction d'information
Vérification et correction orthographique
etc.
Introduction
Niveaux de complexité
1. Tokens
$ wc idees.txt extrait.txt
40
149
947 idees.txt
2294 16638 97724 extrait.txt
2334 16787 98671 total
Lignes, mots, caractères
Connaissances : qu'est-ce qu'un mot ?
Découper un texte en éléments simples
Introduction
Niveaux de complexité
1. Tokens
2. Morpho-syntaxique
Un robot parlant français doit pouvoir produire
Je vais fermer l'autre porte
et non
* Je vais fermer la autre porte
et doit savoir conjuguer Je vais, Il va, Nous allons...
Variations de forme et propriétés des mots
Introduction
Niveaux de complexité
1. Tokens
2. Morpho-syntaxique
3. Syntaxico-sémantique
Le robot doit pouvoir distinguer les ordres et les questions
Ferme toutes les autres portes
Toutes les portes sont-elles fermées ?
Il doit savoir que
* autre fermer je l'porte vais
n'a pas de sens, bien qu'elle contienne les mêmes mots
Structure et sens des phrases
Introduction
Niveaux de complexité
1. Tokens
2. Morpho-syntaxique
3. Syntaxico-sémantique
4. Pragmatique
Le robot doit pouvoir répondre
Non, je ne peux pas
au lieu de
Non, je ne fermerai pas les autres portes
Non, je ne le ferai pas
Comment s'exprimer pour atteindre un objectif
Tokenisation
Tokens : éléments simples d'un texte écrit
Passer d'une séquence de caractères à une séquence de tokens
Je vais fermer l'autre porte
/Je/vais/fermer/l/'/autre/porte/
Définition des tokens
Les mots délimités par des espaces
/l'autre/
/l/'/autre/
/autre,/ /autre/,/
Expressions rationnelles
\w+ une séquence d'1 ou plusieurs caractères alphanumériques
\d+ une séquence d'1 ou plusieurs chiffres
[^\w\s]
un symbole de ponctuation
Algorithme de tokenisation
Entrées : le texte, séquence de caractères ; une ou plusieurs expressions
rationnelles définissant les tokens
Sorties : une séquence de tokens
tant que le texte n'est pas fini {
pour chaque expression rationnelle {
appliquer l'expression au texte en allant le plus loin possible
marquer dans le texte la position obtenue }
si aucune marque alors passer au caractère suivant
sinon {
conserver seulement la marque la plus à droite
copier sur la sortie depuis le caractère courant jusqu'à la marque
prendre comme caractère courant le caractère marqué } }
Tokenisation
Je vais fermer l'autre porte
|
| ^
|
|
|
^
|
|
Je
vais
...
Variante
Les expressions définissent les délimiteurs et non les tokens
Expressions rationnelles
Définition mathématique
- les symboles de l'alphabet et le mot vide
a
- les expressions obtenues avec les opérateurs :
- concaténation
ab
- union
a|b
- itération
a*
Priorités entre opérateurs
le plus prioritaire : itération ; le moins prioritaire : union
Exemples
0|1|2|3|4|5|6|7|8|9
(0|1|2|3|4|5|6|7|8|9)(0|1|2|3|4|5|6|7|8|9)*
Expressions rationnelles
Notations en grep, sed, vi, emacs, flex, perl, python...
Détails des conventions différents pour chaque programme
[0123456789]
0|1|2|3|4|5|6|7|8|9
[0-9]
0|1|2|3|4|5|6|7|8|9
[^a-zA-Z]
1 caractère autre que [a-zA-Z]
CLEF?
CLE|CLEF
[0-9]+
[0-9][0-9]*
.
1 caractère autre que fin de ligne (\n)
^Le
"Le" si placé en début de ligne
dernier$
"dernier" si placé en fin de ligne
\|\(\)\*\[\?\+\.\^\$\\
|()*[?+.^$\
Expressions rationnelles
Notation en python
\s
\w
\d
1 espace, fin de ligne ou tabulation
1 caractère alphanumérique
1 chiffre
Automates finis
Graphes équivalents aux expressions rationnelles
Expression rationnelle
brrr*!
Automate fini équivalent
(reconnaît exactement les mêmes séquences)
r
b
0
1
r
Etats : 0 1 2 3 4
Transitions : 0b1 1r2 2r3 3r3 3!4
Etats initiaux : 0
Etats finaux : 4
2
r
!
3
4
Automates finis
Automate déterministe
1 état initial au plus
si 2 transitions sortent du même état et sont étiquetées
par le même symbole de l'alphabet, alors elles sont
égales
r
b
0
1
r
2
r
!
3
4
Un automate non déterministe
r
b
0
1
r
2
r
!
3
4
Reconnaissance par automate fini
déterministe
Entrées : une séquence de symboles, un automate déterministe
Sorties : oui/non
curseur = le premier symbole de la séquence
état = l'unique état initial de l'automate
tant que vrai {
si curseur à la fin de la séquence alors
si état est final alors renvoyer oui sinon renvoyer non
sinon si transition[état, curseur] vide alors renvoyer non
sinon {
état = transition[état, curseur]
curseur = le symbole suivant } }
Automates finis non déterministes
Peuvent contenir des transitions étiquetées par le mot vide (interdit
dans un automate déterministe)
L'algorithme de reconnaissance est plus compliqué
b
0
1
r
r
2

!
3
4
Automates et expressions rationnelles
Pour toute expression rationnelle il existe un automate fini
équivalent et inversement
Il existe des algorithmes pour construire un automate fini
équivalent à un expression donnée et inversement
Expressions simples : plus faciles à manipuler que les automates
Expressions compliquées : il y a souvent un automate équivalent
plus facile à lire
Exemple :
(1(0|1)*|0)\.((0|1)*1)?|\.((0|1)*1|0)
0
1
0
0
1
.
1
2
6
.
.

3
0 1
4

0
7
1
5
Automates et expressions rationnelles
Trouver un automate fini équivalent à une expression donnée
Union
chemins en parallèle
a
Concaténation
1
0
a|c
c
chemins en série
a
(a|c)d
0
c
d
1
2
Automates et expressions rationnelles
Itération
cycle
ab
(a(ab)*|c)d
a

1
d
2
0
3
c
(a|c)(ab)*d
a
0
c
ab
1
d
2
Introduction à Python
En TP nous utiliserons NLTK, un système écrit en langage Python
Python est un langage à objets interprété
Utilisation interactive : ipython
Utilisation par scripts : python2.4 <fichier_de_script.py>
Commentaires
# Mon premier script en python
Chaînes de caractères
message = "Tokenisation..."
print message
print len(message)
print message + message
repeter = 2
print message * repeter
message = message * repeter
print message
print message[0]
print message[0:5]
print message[5:]
print message[0], message[1]
Tokenisation...
15
Tokenisation...Tokenisation...
Tokenisation...Tokenisation...
Tokenisation...Tokenisation...
T
Token
isation...Tokenisation...
T o
Inspection d'une expression
En mode interactif, quand on écrit une expression, Python répond
en donnant la valeur
>>> message
'Tokenisation...'
>>>
Listes
>>> compte = ["zero", "un", "deux"]
>>> compte[0]
>>> compte[0:2]
>>> suite = compte[-1:] + ['trois']
>>> suite
>>> compte[2] = "2"
>>> compte
>>> compte.reverse()
>>> compte
>>> len(compte)
'zero'
['zero', 'un']
['deux', 'trois']
['zero', 'un', '2']
['2', 'un', 'zero']
3
Méthodes
>>> compte.reverse()
>>> compte
['2', 'un', 'zero']
Le nom d'un objet, un point, le nom d'une méthode, les paramètres
>>> mots = ["antre", "outre", "autre"]
>>> mots.sort()
>>> mots
['antre', 'autre', 'outre']
>>> mots.append("pot")
>>> mots
['antre, 'autre', 'outre', 'pot']
Méthodes
>>> a_rebours = " ".join(compte)
>>> a_rebours
'2 un zero'
>>> phrase = "Je vois l'autre."
>>> phrase.split(" ")
['Je', 'vois', "l'autre."]
Paramètres en ligne de
commande
import sys
sys est le module Python qui gère la ligne de commande et
autres questions liées au système
argv : liste des paramètres passés en ligne de commande
argv[0] est le nom du script
len(argv) est le nombre de paramètres
Itération
total = 0
for mot in mots:
print mot
total += len(mot)
print total
autre
outre
pot
18
La fin du bloc for est indiquée par l'indentation
L'indentation est obligatoire
Expressions rationnelles
>>> import re
>>> from nltk_lite.utilities import re_show
>>> phrase = "Je vois l'autre."
>>> re_show("e", phrase)
J{e} vois l'autre.
>>>
"re" est le module de Python sur les expressions rationnelles
Le tokeniseur de NLTK
>>> from nltk_lite import tokenize
>>> phrase = "Je vois l'autre."
>>> list(tokenize.regexp(phrase, "[^\s]+")
['Je', 'vois', "l'autre."]
>>>
Pour ne pas mélanger les types de caractères dans un
token :
>>> list(tokenize.regexp(phrase, "[\w]+|[^\s]")
['Je', 'vois', 'l', "'", 'autre', '.']
>>>
Fichiers
f = open('phrase.txt', 'rU')
# ouvre le fichier en lecture
text = f.read()
# lit tout le fichier dans une chaîne de caractères
f.close()
# referme le fichier