Chaîne de traitement des URLs

Une fois nos URLs récoltées, nous avons pu commencer la mise en oeuvre de la chaîne de traitement des données.

Création de l'environnement de travail

Voilà notre environnement de travail. Nous pouvions créer les répertoires et sous-répertoires via l'interface graphique, ou via le terminal avec la commande mkdir. Nous avons créé, pour chaque langue, un sous-répertoire dans le répertoire URLS.

Création d'un tableau de liens

C'est là qu'a commencé le plus gros du travail : la rédaction du script permettant d'effectuer tous les traitements. Nous avons d'abord créé un tableau html directement depuis notre script en bash. Il s'agit en fait de quatre tableaux : un par langue. Le script va voir dans notre répertoire URLS et, pour chaque fichier (texte) d'URLs qu'il trouve dans ce répertoire (pour chaque langue), il va créer un tableau. Pour chaque URL d'un fichier, il crée une ligne dans le tableau correspondant.

Le résultat de cette première étape est donc un fichier html qui fait apparaître quatre tableaux les uns à la suite des autres, chacun présentant une première colonne avec le numéro de l'URL (1, 2, 3, etc) et une seconde avec l'URL cliquable.

Aspiration des pages : wget

Il s'agit ensuite d'aspirer les pages html dans un fichier html. Cela se fait grâce à la commande wget. Le résultat de la commande est un fichier html stocké dans notre répertoire PAGES-ASPIREES.

On crée au passage une nouvelle colonne dans notre tableau pour les pages aspirées. Dans cette colonne, on trouve la page html aspirée localement. Son adresse n'est plus l'URL, mais celle de son emplacement sur notre disque dur.

On va également s'assurer que l'aspiration s'est bien déroulée. C'est ce qu'on a appelé "Retour Wget" dans notre tableau. Dans cette colonne, on voit parfois "page d'erreur" : nous avons effectué un petit test pour éliminer les pages d'erreur, et par la même occasion des pages contenant très peu de matière : si une page aspirée a un taille inférieure à un certain seuil, on la déclare "page d'erreur" et on n'effectuera aucun traitement sur elle.

Récupération du texte : lynx

Grâce à la commande lynx, on va maintenant "dumper", c'est-à-dire extraire le contenu textuel de chaque page html aspirée, et le rediriger vers un fichier texte créé à cet effet et stocké dans le répertoire DUMP-TEXT.

Une nouvelle colonne apparaît au tableau, celle des fichiers de dump .txt.

Segmentation du chinois

Après l'extraction du contenu textuel des pages, on vérifie s'il s'agit ou pas de chinois. Si c'est le cas, on découpe le texte en mots existant dans le dictionnaire du segmenteur et on insère un espace entre chaque mot.

Le fichier écrit en chinois passe à la segmentation, puis écrase le fichier d'origine. On poursuit ensuite les traitements, communs à toutes les langues

Détection de l'encodage : file et caetera

Tout ce travail aurait été un jeu d'enfant si toutes les pages html étaient encodées en utf-8. Ce n'est évidemment pas le cas. Dans la pratique, à ce point du travail, nous ne procédons à l'extraction du texte que si le fichier html est encodé en utf-8. Cela implique donc une détection préalable de l'encodage des pages aspirées.

La commande file permet en théorie de détecter l'encodage d'un fichier. En théorie seulement, puisqu'en pratique, elle ne détecte précisément que : ASCII, utf-8, utf-16 et utf-32. Or, un certain nombre de nos fichiers présente un autre encodage que ceux-ci. Par exemple : gbk, gb2312 et big5 pour le chinois, iso-8859-1, iso-8859-15 et windows-1252 pour les langues latines.

De cette difficulté surgit l'arborescence conditionnelle que voici, établie par nos soins afin de maximiser la reconnaissance de l'encodage. Précisons que la commande iconv, présentée dans la section suivante, permet de transcoder un fichier d'un encodage à un autre. Pour cela, elle doit donc connaître (avoir dans sa liste d'encodages connus) l'encodage initial du fichier. Si iconv ne connaît pas l'encodage d'un fichier, elle ne pourra pas le transcoder en utf-8, donc le fichier sera inutilisable.

On regarde l'encodage donné par file :

Si c'est utf-8 :

..... On extrait le texte avec lynx (et on fait les autres traitements)

Sinon :

..... Si l'encodage est précisé dans le code source :

..... ..... On extrait cet encodage (ou charset)

..... ..... Si cet encodage est inconnu de la commande iconv :

..... ..... ..... On ne peut rien faire

..... ..... Sinon (si cet encodage est connu de la commande iconv) :

..... ..... ..... Si c'est de l'utf-8 :

..... ..... ..... ..... On extrait le texte avec lynx (puis autres traitements)

..... ..... ..... Sinon (si c'est un autre encodage qu'utf-8) :

..... ..... ..... ..... On extrait le texte dans son encodage initial avec lynx

..... ..... ..... ..... Puis, avec iconv, on transcode en utf-8 le fichier initial dans un autre fichier (puis autres traitements)

..... Sinon (si l'encodage n'est pas précisé dans le code source) :

..... ..... On ne peut rien faire

Transcodage en utf-8 : iconv

Dans la boucle précédente, on fait appelle à iconv pour transcoder en utf-8 un fichier dont l'encodage est autre qu'utf-8. Ainsi, tous nos fichiers utilisables sont, au final, en utf-8, standard qui permet l'affichage de tous les systèmes d'écriture. Ceci est bien utile, puisque nous devons manipuler des langues latines et du chinois.

On pourra voir dans le tableau que notre structure conditionnelle a bien fonctionné : il n'y a qu'un fichier dont l'encodage n'a pas pu être détecté (il n'était pas présent dans le code source).

On y voit également, à l'issue de ces traitements, une deuxième colonne "Dump utf-8" où l'on trouve le dump initial des fichiers initialement en utf-8, ou le transcodage en utf-8 des dumps de fichiers non initialement en utf-8. Vous suivez ?

Extraction des contextes (txt) : egrep

Nouveau traitement, nouvelle colonne. Nous allons à présent chercher dans nos fichiers texte, dumpés, en utf-8, notre sésame : "alimentation saine". En anglais : "health/healthy food". En espagnol : "alimentación/dieta sana/saludable". En chinois : "健康食品". Toutes ces expressions vont constituer le motif à rechercher dans chaque fichier texte.

On va extraire, pour chaque texte, toutes les lignes contenant le motif, grâce à la commande egrep.

Extraction des contextes (html) : minigrep

On va à présent faire appel à un programme en Perl, le Minigrep multilingue, pour extraire les mêmes contextes, mais de façon plus lisible, plus esthétique, et surtout plus intéressante : on peut voir la ligne qui précède et celle qui suit la ligne faisant apparaître le motif, les numéros de lignes, le motif recherché, le fichier de travail, l'encodage utilisé, le tout avec un jeu de couleurs parlant et s'affichant dans une page html.

Index et comptage

Nous ajoutons à cela deux colonnes supplémentaires. La première, "Fréq motif", donne la fréquence du motif dans le fichier de dump. La seconde, "Index dump", donne l'index de tous les mots présents dans le dump, classés par fréquence.

Cependant, un problème s'est ici posé. Segmenter un texte en mots quand ce texte est en français ou en anglais, rien de plus simple : il suffit de regarder les espaces entre les mots. En revanche, segmenter un texte en chinois est une tâche bien plus complexe car il n'y a pas d'espacements entre les caractères ni les mots chinois. Nous avons dû faire appel à un segmenteur du chinois.

Fichiers globaux

Pour avoir des données générales sur l'ensemble des textes de chaque langue, nous avons concaténé au fur et à mesure les données de chaque fichier texte dans des fichiers globaux (répertoire FICHIERS-GLOBAUX). On trouve un fichier de "Dump global" contenant tous les fichiers en utf-8 extraits ; un fichier "Index dump global" où l'on trouve l'index de ce dernier ; un fichier "Contexte global" où l'on trouve l'ensemble des contextes où le motif a été trouvé ; et enfin un fichier "Index contexte global" contenant l'index des mots de ce dernier.

Ces données globales pourront être exploitées dans la deuxième phase du projet, les Nuages de mots.

Et pour finir, un peu d'esthétique

En plus d'avoir des traitement qui fonctionnent, nous avons ajouté des balises html juste pour la couleur, les bordures et les polices du tableau ; le tout alourdit considérablement script complet. Mais pour le semestre prochain, nos professeurs ont promis de nous enseigner l'utilisation des feuilles de style CSS.