Tutoriel koRpus

La version imprimable n’est plus prise en charge et peut comporter des erreurs de génération. Veuillez mettre à jour les signets de votre navigateur et utiliser à la place la fonction d’impression par défaut de celui-ci.

Analytique et exploration de données
Module: Text mining avec R
◀▬▬▶
⚐ brouillon	☸ intermédiaire
⚒ 2020/03/22
Prérequis
Text mining
Sous-pages et productions: test script
Catégorie: R

Introduction

Korpus est bibliothèque R d'analyse de textes, spécialisée pour la construction d'indices à partir d'une représentation linguistique de textes.

Sites et documentation principaux: Archive cran.r: koRpus: An R Package for Text Analysis; Homepage officielle: Homepage; RDocumentation: koRpus; Vignette: koRpus_vignette.pdf; Manuel officiel: koRpus.pdf; Description: A set of tools to analyze texts. Includes, amongst others, functions for automatic language detection, hyphenation, several indices of lexical diversity (e.g., type token ratio, HD-D/vocd-D, MTLD) and readability (e.g., Flesch, SMOG, LIX, Dale-Chall). Basic import functions for language corpora are also provided, to enable frequency analyses (supports Celex and Leipzig Corpora Collection file formats) and measures like tf-idf.

Korpus permet de:

d'importer du text ascii et qui sera tokénisé et/ou tagué "position of speech"
Calculer pleins d'indices de diversité lexicale et de lisibilité en se basant sur
Faire des analyses de fréquences en utilisant des bases de données de corpus de type Celex (Leipzig) et LCC

Préparation

Prérequis

Pour pleinment profiter de koRpus, il faudrait également installer: TreeTagger (logiciel et base de données pour taguer), une base de données corpus, et des listes de mots (certains indices de diversité et de lisibilité)

Idéalement la grande majorité des analyses exigent qu'un texte soit décomposé en composants Part-of-speech (POS) et il faudrait faire fonctionner le logiciel TreeTagger pour cela (voir qqs. indications dans la section Installation. Alternativement, on peut utiliser un "tokeniser" interne qui coupe un texte en "tokens" et identifie mots, nombres, ponctuations et abréviations. Ce dernier suffit pour calculer des formules de lisibilité, mais donne des résultats moins intéressants pour les autres indices.

Certaines formules de lisibilité exigent des listes de mots. Ces listes sont sous copy-right on règle générale, mais on peut les importer avec un simple fichier texte, un mot par ligne (encodé en UTF-8)

Les analyses de fréquences nécessitent un corpus au format Celex (Leipzig Corpora Collection, Quasthoff, Richter, & Biemann, 2006) ou LCC

Input

Le input devrait être un simple fichier de texte, encodé en format UTF-8

Premiers pas

Créer un objet S4 décomposé en POS utilisant le tokenizer inclus dans koRpus: Il s'agit de lire un fichier et de le tokenizer et tagger avec une méthode simple. Méthode à éviter si TreeTagger est installé (voir ci-dessous); La fonction tokenize() demande le chemin du texte, la langue et d'autre paramètres.

tagged.text.obj <- tokenize("~/methodo/iramuteq/w_txt/Alice.txt", 
                            lang="en", 
                            detect=c(parag=TRUE, hline=TRUE))

Le résultat n'est pas si glorieux. On montre les tokens 1240 à 1245 (sur 6476)

taggedText(tagged.text.obj)
1240                        Word (kRp internal)   NA   NA
1241                      Number (kRp internal)   NA   NA
1242 Sentence ending punctuation (kRp internal)   NA   NA
1243                        Word (kRp internal)   NA   NA
1244                       Comma (kRp internal)   NA   NA
1245                        Word (kRp internal)   NA   NA

Créer un objet Position of speech (POS) en utilisant TreeTagger

TreeTagger permet d'identifier les types de mots et d'annoter le texte. Le résultat va se trouver dans un objet de type S4 que l'on peut utiliser pour des analyses ultérieures.

Le path dans la liste des TT.options doit indiquer le répertoire de base de TreeTagger.

Important: Le preset n'est pas "fr", "mais fr-utf"

tagged.text.objS4 <- treetag("/home/schneide/schneide/methodo/iramuteq/w_txt/Alice.txt", 
            treetagger="manual",
            lang="fr", 
            TT.options= list (path="/home/schneide/tree-tagger/", preset="fr-utf8"))

Le résultat du processus de tokenizing ou POS tagging complet sera stocké dans une variable. Ensuite, on peut appliquer diverses méthodes d'analyse.

La langue (pour vérifier)

> language(tagged.text.objS4)
[1] "fr"

; Le résultat token par token (pour vérifier)
taggedText(tagged.text.objS4)
1240                                adjective   NA   NA
1241              Sentence ending punctuation   NA   NA
1242                                   adverb   NA   NA
1243                              punctuation   NA   NA
1244                                   adverb   NA   NA
1245                         personal pronoun   NA   NA

Afficher des descriptions

La méthode describe() fournit quelques statistiques de base, sous format un peu brut.

describe(tagged.text.objS4)

[....]
$sentences
[1] 237

$avg.sentc.length
[1] 16.1308

$avg.word.length
[1] 5.633272
[....]

Note sur la représentation interne d'un objet de type kRp.analysis

Un objet de texte tagué contient 5 "slots" (propriétés en langage orienté objet): lang, TT.res (qui contient le text tagué) et desc. TT.res est un data frame qui contient 8 colonnes (token, tag, lemma, lttr, etc.) et N lignes (une pour chaque token).

Dans R, rour accéder aux slots d'une classe de type S4, on peut utiliser la fonction slot(slot,obj) ou plus simplement utiliser la notation @:

# Même chose que la fonction description(objS4)
tagged.text.objS4@desc
#ensuite
> tagged.text.objS4@desc$sentences
[1] 237
# Sortir tous les lemma
tagged.text.objS4@TT.res$lemma
   [1] "sommaire"         "@card@"           "description"      "rapide"           "du"              
   [6] "logiciel"         "@card@"           "principe"         "<unknown>"        "@card@"
# Sortir la première ligne
> tagged.text.objS4@TT.res[1,]
     token tag    lemma lttr wclass desc stop stem
1 Sommaire NOM sommaire    8   noun noun   NA   NA
# ... et le token N = 1044
> tagged.text.objS4@TT.res[1044,]
     token tag     lemma lttr wclass        desc stop stem
1044 Boeck NAM <unknown>    5   name proper name   NA   NA

Afficher un résumé d'un texte tagué

>summary (tagged.text.objS4)

  Sentences: 237
  Words:     3823 (16.13 per sentence)
  Letters:   21536 (5.63 per word)

  Word class distribution:

              num        pct
noun         1114 29.1394193
verb          540 14.1250327
preposition   535 13.9942454
adjective     475 12.4247973
article       327  8.5534920
pronoun       259  6.7747842
conjunction   170  4.4467696
name          159  4.1590374
adverb        156  4.0805650
numeral        56  1.4648182
abbreviation   23  0.6016218
symbol          6  0.1569448
interjection    3  0.0784724
fullstop      237         NA
punctuation   438         NA

Produire un histogramme des fréquences des types de mots: plot(tagged.text2.objS4)

Indices de lisiblité

Calcul du Automated Readability Index (ARI)

La formule utilisée par défaut: $ARI=0.5\times {\frac {W}{St}}+4.71\times {\frac {C}{W}}-21.43$ . On pourrait changer les paramètres

ARI (tagged.text.objS4)

Automated Readability Index (ARI)
  Parameters: default 
       Grade: 13.17 

Text language: fr

Calcul du ARI direct

Pour le calculer le ARI on peut faire sans corpus tagué, cad. on lit directement le fichier. Par contre, il faut indique la langue. Comme le manuel explique très mal comment passer des paramètres à ARI, on le fait en deux fois: D'abord définition d'un environnement, puis appel de la fonction ARI.

set.kRp.env (TT.cmd = "/home/schneide/tree-tagger/cmd/tree-tagger-french", lang="fr")

ARI ("/mnt/schneide/methodo/iramuteq/w_txt/Alice.txt",
     force.lang="fr",
     tagger = "kRp.env")

Automated Readability Index (ARI)
  Parameters: default 
       Grade: 12.35 

Text language: fr

Le résultat est différent, peut-être du a différent défauts lors de la tokenisation ?

Comparaison avec trois autres textes

> ARI ("/mnt/schneide/methodo/iramuteq/w_txt/Activate.txt", tagger = "kRp.env")

Automated Readability Index (ARI)
  Parameters: default 
       Grade: 12.47 

> ARI ("/mnt/schneide/methodo/iramuteq/w_txt/Mon-entretien-d-embauche.txt", tagger = "kRp.env")

Automated Readability Index (ARI)
  Parameters: default 
       Grade: 10.62

Calcul de pleins d'indices

readability(tagged.text.objS4, hyphen=NULL,
            index=c("ARI", "Bormuth", "Coleman", "Coleman.Liau", "Dale.Chall", "Danielson.Bryan",
                    "Dickes.Steiwer","DRP", "ELF",
                    "Farr.Jenkins.Paterson", "Flesch", "Flesch.Kincaid", "FOG", "FORCAST", "Fucks",
                    "Harris.Jacobson", "Linsear.Write", "LIX",
                    "nWS", "RIX", "SMOG", "Spache", "Strain", "Traenkle.Bailer", "TRI",
                    "Wheeler.Smith")
)

Le résultat montre que certains indexes ne sont pas calculés car il manque des listes de mots:

Automated Readability Index (ARI)
  Parameters: default 
       Grade: 13.17 

Coleman Formulas
  Parameters: default 
    Pronouns: 6.77 (per 100 words)
     Prepos.: 13.99 (per 100 words)
   Formula 1: 40% cloze completions
   Formula 2: 42% cloze completions
   Formula 3: 43% cloze completions
   Formula 4: 42% cloze completions

Coleman-Liau
  Parameters: default 
         ECP: 28% (estimted cloze percentage)
       Grade: 15.49 
       Grade: 15.49 (short formula)

Danielson-Bryan
  Parameters: default 
         DB1: 9.23 
         DB2: 32.67 
       Grade: 9-12 

Dickes-Steiwer's Handformel
  Parameters: default 
         TTR: 0.35 
       Score: 44.47 

Easy Listening Formula
  Parameters: default 
      Exsyls: 1504 
       Score: 6.35 

Farr-Jenkins-Paterson
  Parameters: default 
          RE: 49.1 
       Grade: >= 13 (college) 

Flesch Reading Ease
  Parameters: en (Flesch) 
          RE: 48.24 
       Grade: >= 13 (college) 

Flesch-Kincaid Grade Level
  Parameters: default 
       Grade: 10.54 
         Age: 15.54 

Gunning Frequency of Gobbledygook (FOG)
  Parameters: default 
       Grade: 13.45 

FORCAST
  Parameters: default 
       Grade: 10.9 
         Age: 15.9 

Fucks' Stilcharakteristik
       Score: 90.87 
       Grade: 9.53 

Linsear Write
  Parameters: default 
  Easy words: 81.66 
  Hard words: 18.34 
       Grade: 11.02 

Läsbarhetsindex (LIX)
  Parameters: default 
       Index: 51.26 
      Rating: difficult 
       Grade: 10 

Neue Wiener Sachtextformeln
  Parameters: default 
       nWS 1: 7.94 
       nWS 2: 8.44 
       nWS 3: 7.39 
       nWS 4: 7.62 

Readability Index (RIX)
  Parameters: default 
       Index: 5.67 
       Grade: 11 

Simple Measure of Gobbledygook (SMOG)
  Parameters: default 
       Grade: 12.95 
         Age: 17.95 

Strain Index
  Parameters: default 
       Index: 8.14 

Tränkle-Bailer Formulas
   Parameters: default 
 Prepositions: 14%
 Conjunctions: 4%
         TB 1: 20.77 
         TB 2: 18.93 

Kuntzsch's Text-Redundanz-Index
  Parameters: default 
 Short words: 2319 
 Punctuation: 2473 
     Foreign: 0 
       Score: -5074.08 

Wheeler-Smith
  Parameters: default 
       Score: 63.46 
       Grade: > 4 

Text language: fr 
Warning messages:
1: Bormuth: Missing word list, hence not calculated. 
2: Dale-Chall: Missing word list, hence not calculated. 
3: DRP: Missing Bormuth Mean Cloze, hence not calculated. 
4: Harris.Jacobson: Missing word list, hence not calculated. 
5: Spache: Missing word list, hence not calculated. 
6: Note: The implementations of these formulas are still subject to validation:
  Coleman, Danielson.Bryan, Dickes.Steiwer, ELF, Fucks, Harris.Jacobson, nWS, Strain, Traenkle.Bailer, TRI
  Use the results with caution, even if they seem plausible!

Indices de diversité

MTLD

Measure of Textual Lexical Diversity (MTLD) est un indice populaire de diversité qui calcule la longueur moyenne d'une séquence ou le taux type/token (TTR) reste supérieur à 0.72. Les auteurs appellent ces séquences des facteurs. Plus il élevé, plus il y a de la diversité.

McCarthy, P. M. & Jarvis, S. (2010). MTLD, vocd-D, and HD-D: A validation study of sophisticated approaces to lexical diversity assessment. Behaviour Research Methods, 42(2), 381–392.

La fonction MTLD est d'une "convience function" pour les analyses disponibles à travers la fonction lex.div.

En utilisant les paramètres de défaut:

> MTLD (tagged.text.objS4)
Language: "fr"

Total number of tokens: 3823
Total number of types:  1347
Total number of lemmas: 541

Measure of Textual Lexical Diversity
                MTLD: 116.92
   Number of factors: 32.7
         Factor size: 0.72
    SD tokens/factor: 57.34 (all factors)
                      58.04 (complete factors only)

Comme toutes les méthodes de koRpus, MTLD permet de spécifier des paramètres.

Note: Utiliser directement un fichier comme pour les analyses de lisibilité n'est pas possible

Analyse d'un autre fichier

MTLD (tagged.text2.objS4)
Language: "fr"

Total number of tokens: 3555
Total number of types:  1199
Total number of lemmas: 500

Measure of Textual Lexical Diversity
                MTLD: 101.8
   Number of factors: 34.92
         Factor size: 0.72
    SD tokens/factor: 54.05 (all factors)
                      51.17 (complete factors only)

lex.div

lex.div est la fonction qui inclut plusieurs indices, à savoir: "TTR", "MSTTR", "MATTR", "C", "R", "CTTR", "U", "S", "K", "Maas", "HD-D", "MTLD" et "MTLD-MA".

Effectuer le calcul de ces indices prend pas mal de temps (plusieurs minutes sur une bonne machine). Par défaut on obtient tous, mais cela se plante (nov 2014)

lex.div (tagged.text.objS4)
# Se plante avec un message d'erreur pour la dernier indice, MTLDMA
 Error in 1:lastValidIndex : result would be too long a vector

Le R de Guiraud

Le R de Guiraud (Guiraud's R) est une simple variante du TTR: $R=V(N)/{\sqrt {(}}N)$

R.ld(tagged.text.objS4)
Language: "fr"

Total number of tokens: 3823
Total number of types:  1347
Total number of lemmas: 541

Guiraud's R
   R: 21.79

Installation

Le paquet koRpus est disponible via R
Par contre, pour pouvoir pleinement profiter il faut aussi installer/configurer Treetagger et qui nécessite aussi l'installation du langage Perl. Les liens sont disponibles dans la documentation de ce paquet.

Windows

Pour faire marcher Treetagger, il faut d'abord installer le langage Perl

On conseille Active Perl. Il a été installé facilement sous Win 8.1 et il marche. Prenez la Community edition (gratuite)

Ensuite il faut suivre les Instructions à la lettre

Il faut télécharger et dézipper Treetagger
Il faut installer Treetagger à la racine c:\. Si non, il faut adapter les fichiers *.bat dans le répertoir bin (ma solution ci-dessous)

set TAGDIR=C:\soft\TreeTagger

Finalement, il faut télécharger les paquets de langues (Parameter files). Il faut les dézipper dans le répertoire lib !
Il faut corriger le nom du paquet français (en tout cas en nov. 2014) de french.par à french-utf8.par

Si vous installez 3 langues, il faut avoir cette hiérarchie de fichiers:

Directory: C:\soft\TreeTagger

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
d----        03.12.2014     20:12            bin
d----        20.10.2014     18:09            cmd
d----        03.12.2014     20:25            lib
-a---        20.10.2014     18:09       3138 INSTALL.txt
-a---        20.10.2014     18:09       7922 README.txt

 Directory: C:\soft\TreeTagger\bin

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        20.10.2014     18:09        928 chunk-english.bat
-a---        20.10.2014     18:09        929 chunk-french.bat
-a---        20.10.2014     18:09        923 chunk-german.bat
-a---        20.10.2014     18:09        522 tag-dutch.bat
-a---        03.12.2014     20:12        541 tag-english.bat
-a---        20.10.2014     18:09        536 tag-english.bat~
-a---        03.12.2014     20:12        537 tag-french.bat
-a---        20.10.2014     18:09        532 tag-french.bat~
-a---        20.10.2014     18:09        526 tag-german.bat
-a---        20.10.2014     18:09        536 tag-italian.bat
-a---        20.10.2014     18:09        633 tag-spanish.bat
-a---        20.10.2014     18:09     187406 train-tree-tagger.exe
-a---        20.10.2014     18:09     193038 tree-tagger.exe

  Directory: C:\soft\TreeTagger\cmd

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        20.10.2014     18:09       5817 filter-chunker-output-french.
-a---        20.10.2014     18:09       2287 filter-chunker-output-german.
-a---        20.10.2014     18:09       2226 filter-chunker-output.perl
-a---        20.10.2014     18:09       1714 mwl-lookup-greek.perl
-a---        20.10.2014     18:09       2282 mwl-lookup.perl
-a---        20.10.2014     18:09       5031 tokenize.pl
-a---        20.10.2014     18:09       5308 utf8-tokenize.perl

    Directory: C:\soft\TreeTagger\lib

Mode                LastWriteTime     Length Name
----                -------------     ------ ----
-a---        20.10.2014     18:09        564 dutch-abbreviations
-a---        20.10.2014     18:09        668 english-abbreviations
-a---        20.05.2014     16:26   14411865 english-utf8.par
-a---        20.10.2014     18:09        674 french-abbreviations
-a---        11.01.2010     09:57   18042133 french-utf8.par
-a---        20.10.2014     18:09       9154 german-abbreviations
-a---        07.12.2012     12:21   37479715 german-utf8.par
-a---        20.10.2014     18:09        328 italian-abbreviations
-a---        20.10.2014     18:09         25 spanish-abbreviations
-a---        20.10.2014     18:09       3662 spanish-mwls

Ubuntu

Sous Ubuntu, on peut installer Treetagger de la façon suivante (enfin il faudrait aussi vérifier que ce ne soit pas fait automatiquement par la distribution Debian. Nous, on a installé koRpus via R-Studio

Installer Perl si ce n'est pas déjà fait

sudo apt-get install perl

Créer un répertoire, par exemple tree-tagger
Télécharger tous les fichiers indiqués dans le manuel

sh install-tagger.sh

Editer le fichier ~/.bashrc et ajouter (par exemple)

export PATH=/home/votre_login/tree-tagger/cmd:/home/votre_login/tree-tagger/bin:$PATH

Tester:

echo 'Vive big brother!' | tree-tagger-english
	reading parameters ...
	tagging ...
	 finished.
Vive	NP	Vive
big	JJ	big
brother	NN	brother
!	SENT	!

Korpus semble aussi marcher avec RKWard, une IDE/GUI pour R

Liens et bibliographie

Bibliographie

Michalke, M. (2012, April). koRpus -- ein R-paket zur textanalyse. Paper presented at the Tagung experimentell arbeitender Psychologen (TeaP), Mannheim.

Helmut Schmid (1995): Improvements in Part-of-Speech Tagging with an Application to German. Proceedings of the ACL SIGDAT-Workshop. Dublin, Ireland.