Dans le cadre de la formation pluriTAL 2016-2017, notre groupe de travail a choisi comme sujet du projet de premier semestre de traiter la notion de "stress". Pour résumer le contenu du projet, il suffit de décrire les différentes étapes que nous avons parcourues depuis ces derniers mois:

    ◍ Récolter manuellement des pages web contenant une ou plusieurs occurrences du thème choisi (le "motif")

    ◍ Élaborer un script en langage bash

    ◍ Analyser le résultat par "Le Trameur", développé par notre enseignant, M. Serge Fleury.

    ◍ Élaborer un site montrant nos résultats.

Notre projet se fait en quatre langues et cinq écritures:

Étapes

1. Choix d’un thème sur lequel travailler
2. Constitutions de fichiers d’URLs
3. Réalisation d’un script en bash
• aspiration des pages
• dump des contenus textuels
• récupération de l’encodage suivi d’un transcodage si nécessaire
• création de contextes textuels et html (merci minigrep)
• écriture des résultats dans un tableau html
4. Segmentation des textes en chinois avec Stanford Word Segmenter
5. Utilisation du logiciel le Trameur et d’iTrameur
• graphes de co-occurences
• (optionnel) récupérer les fichiers statistiques qu’on pourra utiliser pour créer les nuages de mots
6. Création de nuages de mots
7. Réalisation de ce site web, pour présenter nos résultats (ce qui a demandé un apprentissage des langages html et css)

Outils

1.LeTrameur

Le Trameur est un logiciel de textométrie, nous l’avons principalement utilisé afin de repérer les co-occurents des mots en lien avec le stress. Cette étape nous a également permis de nous rendre compte de l’importance des données collectées. Les dumps des articles étaient pollués par un certain nombre de données textuelles qui ne présentait pas d’intérêt pour nous (menus de navigation des pages web, listes d’articles mis en avant sur la page...). L’analyse avec le Trameur nous a montré qu’afin d’obtenir des analyses satisfaisantes, il est nécessaire de nettoyer les fichiers constituant notre corpus (automatiquement, de préférence).

2.Le choix des URLS

Nous avons choisi de collecter des URLs d’articles de presse, afin de constituer un corpus plus homogène. Pour constituer le corpus en anglais, les sites ont été sélectionnés en faisant attention à varier les régions

3.Le nuage des mots

Pour créer les nuages de mots, nous avons utilisé plusieurs outils: WordItOut, Word cloud generator

4.Segmentation du chinois

Le chinois est une langue très différente que les langues européennes, parce qu'il y pas de espaces entre les mots, donc quand on analyse le chinois il faut segmenter les mots en avance. Pour la segmentation, c'est Marine qui a trouvé l'outil Stanford Word Segmenter. C'est un logiciel développé par Université Stanford qui est le leader dans le domaine de TAL, donc c'est un outil très fiable, cependant, il reste encore des mots mal séparés, sa performance est moins pertinente sur le sinogramme traditionnel :il a y des faux mots, c'est-à-dire des phrasés sont traités comme des mots, ça influence un peu le résultat.

5.Langage Bash

C'est une sorte de boîte à outils, très puissante mais aussi très exigeante, qui nous est proposée pour faire nos premiers pas en programmation. Le Bash (Bourne-Again SHell), langage du shell UNIX, permet de travailler en ligne de commande ou bien dans des programmes élementaires constitués de commandes de ce langage, les scripts. Pourtant, ce langage n'a pas toujours très bonne presse auprès des programmeurs : peu portable, pas assez abstrait (ses données sont réputées "non typées"), il souffre de la comparaison avec les langages dédiés à la programmation tels que la famille des C, le Javascript, le Python et consorts qui sont effectivement plus spécialisés, donc plus puissants. Pourtant, cela reste un outil très pratique qui a connu une évolution progressive au cours de ses diverses versions, et pour peu qu'on soit assez familier avec ses subtilités, il sait se montrer très utile, un peu à la manière d'un couteau suisse.
Une alternative était de recourir au programme "Gromoteur" développé par M. Kim Gerdes, un autre de nos enseignants. C'est un peu le nec plus ultra par rapport à nos besoins, car il fonctionne de manière similaire et donne des résultats beaucoup plus avancés, avec toutes sortes de pré-traitements ; nous avons cependant préféré la démarche "do it yourself" consistant à mettre en place nos propres outils rudimentaires pour tenter d'aboutir à des résultats à peu près équivalents.

6.Le script

Comme c'est la première fois d'écrire un programme, au début c'est très difficile :les commandes inconnues, le script d'exemple a l'air très compliqué...Pour moi, le plus important est de comprendre le script, construire un diagramme pour le script est un bon choix, il nous aide de comprendre la logique(cliquez pour l'agrandir):

Puis il faut trouver un bon éditeur à écritre notre propre script, et j'ai utilisé textewrangle au début, ça m'a apporté des difficultés : pas de mémoire des noms de variables, pas de couleurs à distinguer commandes et variables...Après, j'ai connu Atom qui est un éditeur pas mal, un bon éditeur facilite beaucoup le travail.

7.Le site

C'est aussi la première fois de construire un site. Ça semble peut-être que c'est facile puisqu'on peut trouver pas mal de modèles de site sur Internet, ce que l'on doit faire est juste d'ajouter le contenu. Mais juste comme le script de bash, il faut comprendre le script de modèle en avance pour qu'on puisse ajouter le contenu dans la bonne place d'une bonne manière, de plus, si on veux ajouter styles, il faut apprendre plus de commandes de CSS et HTML, par exemple, j'ai dépensé beaucoup de temps à trouver une façon de mettre le script dans une page web, de plus, plein de détails à régler et à vérifier. Heureusement il y a un site qui donne des instructions de connaissances de construction de site web: W3School

A partir du tableau de sinogrammes simplifiés, on observe que les encodages de presque une moitié des sites sont gb2312, c’est bien différent que la situation des sites en autres langues, y compris les sites de sinogrammes traditionnels: leurs encodages sont presque tous utf-8.

GB2312 est le nom Internet enregistré pour un jeu de caractères officiels de la République populaire de Chine, utilisé pour les caractères chinois simplifiés, publié en 1985. GB est l'abréviation de Guojia Biaozhun, qui signifie Standard National en chinois. Alors que GB2312 couvre plus de 99% des caractères de l'usage contemporain, des textes historiques et de nombreux noms restent hors de portée. Mais pour les sites de presse ou de nouvelles, ça déjà suffit. Les caractères dans GB2312 sont disposés dans une grille 94x94 (comme dans ISO 2022), et le codepoint à deux octets de chaque caractère est exprimé dans la forme kuten (ou quwei), qui spécifie une rangée (ku ou qu) et la position de la Caractère dans la ligne (cellule, ten ou wei).Donc on sait que dans GB2312, un caractère tient deux octets.

L'encodage UTF-8 est apparu en 1996, c'est un codage de caractères informatiques conçu pour coder l'ensemble des caractères du "répertoire universel de caractères codés", défini par Unicode. UTF-8 est un encodage de longeur variante, c'est-à-dire que les longeurs de code sont diférentes, pour les caractères chinois, chaque caractère utilise généralement 3 octets, et pour des caractères plus anciens rarement utilisé, ils utilisent eventuellement 4 octets.

En comparant encodage UTF-8 et GB2312, on peut trouver la raison de l'utilisation populaire de GB2312 en Chine: GB2312 correspond aux besoins d'utilisation quotidienne en utilisant moins d'octets pour chaque caractère que UTF-8(GB2312: 2octets/caractère, UTF-8 3octets/caractère); d'autre côté, GB2312 est apparu plus tôt que UTF-8, donc il y a des sites construits avant 1996 qui préfèrent de continuer utiliser l'encodage qu'ils utilisent depuis longtemps, pour un grand site web, c'est difficide de changer l'encodage.

9.Les spécificités du script synthétique

  Notre intention était de se réapproprier le programme générique construit sur la base fournie par les enseignants et de présenter quelque chose d'un peu plus personnel qui permettrait aussi d'utiliser les spécificités de Bash. Et nous avons plutôt réussi cette tâche, semble-t-il, puisque le second script fonctionne tout autant. Il sera certes plus ardu à comprendre, car il met en pratique des éléments un peu avancé de la syntaxe Bash, mais en même temps, la compréhension de la structure sous-jacente paraît moins compliquée, justement grâce à cet effort de synthèse.
Plusieurs points distinguent cette seconde version :

• Il ne s'agit plus d'un programme interactif. Plutôt que de saisir les paramètres au clavier après le lancement du script, il faut un fichier d'initialisation qui contient deux lignes avec les informations en question : l'emplacement du fichier d'URLs sur la machine et le motif (pour en compter les occurrences); la première section du corps du programme consiste à vérifier qu'il y a bien un et un seul argument passé au script en ligne de commande qui pointe vers un fichier lisible et conforme. Si toutes ces conditions sont vérifiées, le script s'exécute normalement en affichant sur la console des messages sur le traitement de chaque URL, puis termine avec quelques lignes de résultat et renvoie un code de sortie 0 qui indique que tout s'est déroulé correctement.
• En ce qui concerne l'aspect synthétique, il repose principalement sur la simplification de la structure logique du script initial ; en effet, celui-ci propose une série de tests sur chaque URL pour vérifier successivement si l'aspiration de la page s'est bien passée, si l'encodage d'origine a été reconnu et si c'est de l'UTF-8 ou non. La plupart de ces tests sont imbriqués les uns dans les autres avec des blocs correspondants de lignes de résultats, si bien que la structure générale du script d'origine est plutôt lourde et difficile à appréhender. Notre parti pris pour résoudre ce problème a été de tout simplifier en recourant à des fonctions et des variables (on a tout "paramétrisé").
  La première fonction sert à vérifier l'encodage d'un fichier passé en argument et renvoie la variable contenant cette information ; il faudrait toutefois l'améliorer car elle repose sur le résultat de la commande 'file' qui n'est pas toujours très fiable.
  La seconde regroupe tous les traitements de sortie qui permettent de récupérer le contenu textuel de la page web ciblée, l'intégrer au corpus, compter les occurrences du motif et donner l'index (liste de tous les mots du texte et leur fréquence absolue).
  Les tests successifs sont remplacés par une instruction de branchement 'case' qui vérifie le résultat de la fonction d'encodage et selon les trois cas de figure possibles (pas reconnu/UTF-8/autre), effectue les traitements nécessaires : l'écriture des résultats dans le tableau final et le cas échéant, la conversion au format UTF-8 et l'ajout des données au corpus. Du coup, le bloc qui génère une nouvelle ligne du tableau n'apparaît qu'une fois dans le script en fonction du branchement.
• En dernier lieu, cette version alternative traite un peu différemment l'arborescence du projet dans la mesure où elle vérifie la présence des dossiers de résultats (aspirées, dumps, contextes et tableaux) et les crée si besoin. Elle ne regroupe pas tous les résultats dans un tableau unique mais en ajoute un par fichier d'URLs traité et ajoute les fichiers aspirée, dump et contexte de chaque URL dans un dossier de résultats identifié par fichier d'URLs (les fichiers d'index sont placés dans le même dossier que les dumps); de même, les noms de fichier ont été un peu plus explicités que les simples références à leur valeur d'indexation. La mise en forme des tableaux est aussi un peu différente : la colonne "dump initial" a été supprimée car rendue obsolète, comme celle de "statut curl", jugée redondante et on a rajouté deux lignes de résultats avec les liens vers les fichiers globaux ainsi que le nombre total d'occurrences relevées.

10.Le script "nettoyeur"

  C'est l'outil le plus rudimentaire mais il a le mérite d'accomplir soigneusement sa tâche. Il purge le corpus en éliminant ce qu'on lui demande et accepte des expressions régulières (du moins celles reconnues par 'sed' car il est construit autour de cette commande). Dans les fichiers de dump global, il peut y avoir en effet beaucoup d'informations inutiles et de toute façon il est impératif, avant d'entamer les analyses, d'éliminer toutes sortes de mots grammaticaux (articles, pronoms, prépositions, etc.) qui pourraient fortement compromettre les résultats. Le script fonctionne de la manière suivante : on indique le fichier cible comme argument du script et on obtient en sortie deux nouveaux fichiers, un pour le fichier filtré et un fichier "crible" qui contient l'ensemble des formes supprimées dans le fichier source (qui reste intact).
Une particularité de ce script est qu'il comprend un document embarqué (Here-document) qu'il faut modifier pour constituer le filtre. En gros, il faut écrire spécifiquement le mot ou l'expression régulière que l'on veut nettoyer dans un espace prévu à cet effet (entre les lignes "LISTE_FILTRE"). Concrètement, nous avons dû procéder par affinements successifs pour constituer la liste de formes à filtrer ; il s'est avéré particulièrement pratique de partir d'un nuage de mots du dump global et de relever tout ce qui semblait superflu, et on a encore augmenté la liste en utilisant les premiers résultats donnés par le Trameur et en parcourant manuellement l'ensemble du document. Il est donc pratique de conserver cette liste dans un autre fichier qu'il suffit de copier-coller dans le script. Et voilà !
Le seul petit inconvénient, si l'on excepte le fait qu'il faut modifier la partie filtre du script à chaque usage au lieu de passer un fichier en argument, est qu'il est impératif de lancer le script depuis le même dossier que celui où se trouve le fichier cible.

Difficultés essentiels rencontrées :

Vous pouvez voir nos scripts ici et les télécharger.

*Pour voir les lignes longues il faut glisser vers droite.

Le script de Mengwei

Comme je travaille sur Mac pendant que les professeurs nous a donnés l'exemplaire de script de Windows, j'ai renconté beaucoup de problèmes sur les commandes,donc j'ai souvent cherché des solutions sur Internet donc il y a peut-être des commandes un peu différentes. J'ai insérer le procédé de concanétation des textes dans mon script puisque le programme de concaténation ne fonctionne pas sur mon ordianateur.

#!/bin/bash
    #--read files--#
    read folder
        read tablefileread motifecho "le dossier d'URLS sont: ${folder}"echo "le fichier contenant le tableau est: ${tablefile}"echo "le modif est: ${motif}"nomtable=1#--write the style of table--#echo "<html><head><style>p{text-align:center;}hr{color:red;width=80%;}table{margin-left:10%; width:80%;text-align:center;border-style:solid;border-width:1px;border-color:grey;}tr{text-align:center;}td{text-align:center;border-style:solid;border-width:1px;border-color:grey;}</style></head><body>">${tablefile}#--first boucle for every file,each file has a table--#for file in `ls ${folder}`{#--the title of table--#	nomurl=1	echo "${file}"	echo "<p><hr /></p>">> ${tablefile}	echo "<table>">> ${tablefile}	echo "<tr><td colspan=\"11\">Table n<sup>o</sup>${nomtable}</td></tr>">> ${tablefile}	echo "<tr>	<td><b>N&deg</b></td>	<td><b>Lien</b></td>	<td><b>Code CURL</b></td>	<td><b>Statut CURL</b></td>	<td><b>Page Aspir&eacute;e</b></td>	<td><b>Encodage Initial</b></td>	<td><b>DUMP initial</b></td>	<td><b>DUMP UTF-8</b></td>	<td><b>CONTEXTE UTF-8</b></td>	<td><b>CONTEXTE HTML UTF-8</b></td>	<td><b>Fq MOTIF</b></td>	</tr>">> ${tablefile}#--strat to analyse each lien in a file--#	for url in `cat ${folder}/${file}`	{	echo ${url}	echo "Techecharement de ${line} vers ./PAGES-ASPIREES/${nomtable}-${nomurl}.html"	curl ${url} -o ./Pages-ASPIREES/"${nomtable}-${nomurl}".html	b=$?	echo ${b}	echo "CODE RETOUR CURL: $?"#--vérifier l'execusion par $?--if 0, telechargement succes, else return the error message#		if [ $b = 0 ];		then echo "telechargement reussite"        statu1=$(curl -sI ${url} | head -1)        statu2=$(curl --silent --output ./PAGES-ASPIREES/"${nomtable}-${nomurl}".html --write-out "%{http_code}" ${url})        encodage=$(curl -sI ${url}|egrep -i "charset=" | cut -f2 -d= | tr -d "\n" | tr -d "\r"| tr "[:upper:]" "[:lower:]")        echo "Encodage $url : $encodage"#--it's possible that the curl can't work,so we should use other methods to get the encodage, first choice is "egrep", then "file" which is the last choice--#            if [ ! -n "$encodage"  ];            then            encodage=$(egrep -iom 1 "charset *=[^ \>]+" ./PAGES-ASPIREES/"${nomtable}-${nomurl}".html | cut -d= -f 2 | tr -d "\"" | tr -d "\n" | tr -d "\r" | tr -d "\'" | tr -d "\/" | tr "[:upper:]" "[:lower:]")            type='via egrep'            echo $encodage                if [ ! -n "$encodage"  ]                then                encodage=$(file -I ./PAGES-ASPIREES/"${nomtable}-${nomurl}".html | cut -d= -f2)                type='via file'                echo $encodage                    if [ ! -n "$encodage"  ]                    then                    echo "encodage est impossible a detecte"fi                else                echo "encodage est detecte dans egrep: $encodage"                fi            else            type='via curl'            echo "success, encodage est: $encodage"            fi#--the test for utf-8, if the encodage of the site is utf8, wo can analyse the content directly, else we CONVERTIR the original encodage to utf-8--#        if [ $encodage = 'utf-8' ];        then            echo "DUMP de $url via lynx"            lynx -dump -nolist -assume_charset=${encodage} -display_charset="UTF-8" ${url} > ./DUMP-TEXT/"$nomtable-$nomurl".txt            echo "<t=$nomtable-$nomurl.txt>">>./DUMP-TEXT/"concatenationDUMP_$nomtable".txt            lynx -dump -nolist -assume_charset=${encodage} -display_charset="UTF-8" ${url} >> ./DUMP-TEXT/"concatenationDUMP_$nomtable".txt            egrep -i -C 2 --color $motif ./DUMP-TEXT/"$nomtable-$nomurl".txt>./CONTEXTES/"$nomtable-$nomurl".txt            echo "<t=$nomtable-$nomurl.txt>">>./CONTEXTES/"concatenationCONTEXT_$nomtable".txt            egrep -i -C 2 --color $motif ./DUMP-TEXT/"$nomtable-$nomurl".txt>>./CONTEXTES/"concatenationCONTEXT_$nomtable".txt            nbmotif=$(egrep -coi $motif ./DUMP-TEXT/"$nomtable-$nomurl".txt)            perl minigrep/minigrepmultilingue.pl UTF-8 DUMP-TEXT/"$nomtable-$nomurl".txt minigrep/motif.txt            mv resultat-extraction.html ./CONTEXTES/"$nomtable-$nomurl".html            echo $nbmotif            echo "ECRITURE RESULTAT dans le tableau"            echo "<tr>            <td>${nomurl}</td>            <td><a href="${url}">lien n<sup>o</sup>$nomurl</a></td>            <td>${statu2}</td>            <td><small>${statu1}</small></td>            <td><a href='./PAGES-ASPIREES/${nomtable}-${nomurl}.html'>n<sup>o</sup>${nomtable}-${nomurl}</a></td>            <td>${encodage},$type</td>            <td>-</td>            <td><a href='./DUMP-TEXT/$nomtable-$nomurl.txt'>DUMP n<sup>o</sup>$nomtable-$nomurl</a></td>            <td><a href='./CONTEXTES/$nomtable-$nomurl.txt'>CONTEXTE n<sup>o</sup>$nomtable-$nomurl</a></td>            <td><a href='./CONTEXTES/$nomtable-$nomurl.html'>CONTEXTE n<sup>o</sup>$nomtable-$nomurl</a></td>            <td>$nbmotif</td>            </tr>" >>${tablefile}#--the problem of the no utf-8 site is that it's possible its encodage dosen't exist in iconv list, so it needs to verify, then do the iconv--#        else            newencodage=`tr '[a-z]' '[A-Z]' <<<"$encodage"`            iconv -l | egrep $newencodage            x=$?            echo $x                if [ $x = 1 ];                then                    echo "encodage existe pas dans iconv"                    echo "ECRITURE RESULTAT dans le tableau"                    echo "<tr>                    <td>${nomurl}</td>                    <td><a href="${url}">lien n<sup>o</sup>$nomurl</a></td>                    <td>${statu2}</td>                    <td><small>${statu1}</small></td>                    <td><a href='./PAGES-ASPIREES/${nomtable}-${nomurl}.html'>n<sup>o</sup>${nomtable}-${nomurl}</a></td>                    <td>${encodage}</td>                    <td>-</td>                    <td>-</td>                    <td>-</td>                    <td>-</td>                    </tr>" >>${tablefile}                else                    echo "encodage detecte"                    #problem                    lynx -dump -nolist -assume_charset=$encodage -display_charset=$encodage $url >./DUMP-TEXT/"$nomtable-$nomurl-1".txt                    #file pas assez fiable, uilise pas file pour les sites chinois qui utilise gb2312                     #filencodage=$file -I ./DUMP-TEXT/"$nomtable-$nomurl-1".txt | cut -d= -f2)                    #echo $filencodage                    iconv -f $encodage -t UTF-8 ./DUMP-TEXT/$nomtable-$nomurl-1.txt >./DUMP-TEXT/$nomtable-$nomurl-2.txt                    echo "<t=$nomtable-$nomurl-2.txt>">>./DUMP-TEXT/"concatenationDUMP_$nomtable".txt                    iconv -f $encodage -t UTF-8 ./DUMP-TEXT/$nomtable-$nomurl-1.txt >>./DUMP-TEXT/"concatenationDUMP_$nomtable".txt                    #encodageconv=$(file -I ./DUMP-TEXT/$nomtable-$nomurl-2.txt)                    #echo $encodageconv                    egrep -i -C 2 --color $motif ./DUMP-TEXT/"$nomtable-$nomurl-2".txt>./CONTEXTES/"$nomtable-$nomurl".txt                    echo "<t=$nomtable-$nomurl.txt>">>./CONTEXTES/"concatenationCONTEXT_$nomtable".txt                    egrep -i -C 2 --color $motif ./DUMP-TEXT/"$nomtable-$nomurl-2".txt>>./CONTEXTES/"concatenationCONTEXT_$nomtable".txt                    nbmotif=$(egrep -coi $motif ./DUMP-TEXT/"$nomtable-$nomurl-2".txt)                    perl minigrep/minigrepmultilingue.pl UTF-8 ./DUMP-TEXT/"$nomtable-$nomurl-2".txt minigrep/motif.txt                    mv resultat-extraction.html ./CONTEXTES/"$nomtable-$nomurl".html                    echo $nbmotif                    echo "ECRITURE RESULTAT dans le tableau"                    echo "<tr>                    <td>${nomurl}</td>                    <td><a href="${url}">lien n<sup>o</sup>$nomurl</a></td>                    <td>${statu2}</td>                    <td><small>${statu1}</small></td>                    <td><a href='./PAGES-ASPIREES/${nomtable}-${nomurl}.html'>n<sup>o</sup>${nomtable}-${nomurl}</a></td>                    <td>${encodage}, $type</td>                    <td><a href='./DUMP-TEXT/$nomtable-$nomurl-1.txt'>DUMP n<sup>o</sup>$nomtable-$nomurl-1</a></td>                    <td><a href='./DUMP-TEXT/$nomtable-$nomurl-2.txt'>DUMP n<sup>o</sup>$nomtable-$nomurl-2</a></td>                    <td><a href='./CONTEXTES/$nomtable-$nomurl.txt'>CONTEXTE n<sup>o</sup>$nomtable-$nomurl</a></td>                    <td><a href='./CONTEXTES/$nomtable-$nomurl.html'>CONTEXTE n<sup>o</sup>$nomtable-$nomurl</a></td>                    <td>$nbmotif</td>                    </tr>" >>${tablefile}                fi        fi					let "nomurl=nomurl+1"    else        echo "telechargement echoue"    fi		}			echo "</table>" >>${tablefile}			let "nomtable=nomtable+1"}		echo "</body></html>">>${tablefile}#----The end------#;

Pour les quartre langues étudiés, on fait en total 5 tableaux: