« Text mining avec R » : différence entre les versions

De EduTech Wiki
Aller à la navigation Aller à la recherche
mAucun résumé des modifications
Ligne 134 : Ligne 134 :
....
....


== Importer des fichiers avec le paquet tm ==
== Survol d'analyses ==


'''''tm''''' est le paquet "text mining" le plus populaire de [[R]]. Comme on va surtout travailler avec ce paquet, il va falloir [[R#Installation_de_paquets|l'installer]] si nécessaire.
== Préparation de documents ==


Le paquet '''''tm''''' est conçu pour marcher avec une variété de formats: textes simples, articles/papiers en PDF ou Word, documents Web (HTML, XML, SGML), etc. Il fournit entre autre les fonctionnalités suivantes:
* Pour préparer des "sacs de mots" nettoyés et pour fabriquer des tableaux de fréquences ou de proximité, on conseille d'utiliser [[Tutoriel tm text mining package|tm]]
* Un dispositif pour analyser des corpus (une structure de données avec des fonctions de construction)
* Une fonction pour appliquer des fonctions à l'ensemble des textes d'un corpus.
* Des fonctions nouvelles pour l'analyse de textes


Pour utiliser '''tm''':
== Analyses de type ALCESTE ==
<code>library(tm)</code>


Si nécessaire, installez ce paquet avec R-Studio ou tapez:
[http://www.iramuteq.org/ Iramutec] est un logiciel (Interface de R) qui permet de faire un certain nombre d'analyses statistiques relativement facilement. On peut considérer que ce logiciel est une implémentation open source des fonctionnalités populaires du logiciel commercial [http://www.image-zafar.com/ Alceste] et de la méthode ALCESTE ("Analyse des Lexèmes Cooccurrents pour un Ensemble de Segmentations du Texte en Énoncés") sous-jacent développée par Max Reinert.
<code> install.packages("tm")</code>
 
=== Importation de documents et corpus ===
 
Le <code>Corpus</code> est la structure R qui représente une '''collection de documents''' que l'on veut analyser. Cette structure doit être construite en important des textes.
 
Il existe 2 versions:
* <code>VCorpus</code> alias >code>Corpus</code> (volatile, lorsqu'on arrête R, il faut reconstruire le corpus ...
* <code>PCorpus</code> (persistant, définit un endroit unique où le corpus est stocké)
 
; Syntaxe de Vcorpus:
: On doit indiquer le source du corpous (où le trouver) et la méthode pour lire les divers fichiers (ou autre sources).
: <code>Vcorpus</code>(''objet_source'', ''méthode_pour_lire'')
:par exemple:
: <code>VCorpus( DirSource(txt, encoding = "UTF-8"), readerControl = list(reader=readPlain, language="fr") )</code>
: <code>VCorpus( DirSource(txt, encoding = "UTF-8") </code> # on utilise les défauts
 
Voici quelques éléments à savoir lorsqu'on construit un corpus
# Identifier un type de ''''source''''' de données: soit <code>DataframeSource</code>, <code>DirSource</code>, <code>URISource</code>, <code>vectorSource</code> ou <code>XMLSource</code>
# Definir le '''''reader''''', c-a-d. on peut définir la '''''manière dont le texte''''' est lu avec <code>readerControl=</code>. On peut notamment définir le type de document à lire (<code>readDOC</code>, <code>readPDF</code>, <code>readPlain</code>, <code>readXML</code>, <code>readTabular</code>), la langue <code>language=...</code>.
 
Le type de sources et de readers de votre installation R peut être affiché avec les commandes suivantes:
<source lang="javascript">
getReaders() # affiche toute la liste de readers
getSources() # affiche la liste des types de sources
</source>
 
Chaque source possède un lecteur (reader) par défaut. Par exemple pour <code>DirSource</code>, c'est <code>readPlain</code>.
 
=== Exemple lecture de fichiers textes du tutoriel officiel en format UTF-8 ===
 
Ces fichiers se trouvent déjà dans l'installation de R, d'où l'utilisation de <code>system.file</code>
<source lang="javascript">
# Tester si un répertoire existe et retourner son nom complet
# Tester et stocker le nom d´un sous-répertoire tm/texts/txt dans votre bibliothèque système
txt <- system.file("texts", "txt", package = "tm")
# Charger le texte de chaque fichier
ovid <- VCorpus(DirSource(txt, encoding = "UTF-8"), readerControl = list(language = "lat"))
</source>
 
'''Inspection et utilisation de corpus'''
 
Pour vérifier les contenus on peut afficher le tout ou encore juste quelques éléments, par exemple:
<source lang="javascript">
# print a short overview
print(ovid)
 
# show all
inspect(ovid)
ovid
 
# display the second document
ovid[[2]]
</source>
 
=== Lecture de fichiers locaux ===
 
Pour lire un ensemble de fichier locaux,on conseille de les mettre dans un sous-répertoire d'un répertoire pour le text mining.
 
''le "working directory" définit le répertoire de travail par défaut, selon la logique de votre plateforme. On peut modifier ce working directory.
<source lang="javascript">
# Afficher le répertoire de travail courrant
getwd()
[1] "C:/Users/dschneid/Documents"
# changer le répertoire de travail
setwd "C:/dks/R"
</source>
 
On peut utiliser la fonction ''file.path'' pour indiquer ou trouver des fichiers d'une façon indépendante de la plateforme. Si sous Windows, les fichiers se trouvent dans <code>D:\data\exemples\txt</code>, utilisez du code comme <code>chemin <- file.path("d:", "data", "exemples", "txt") </code>. Pour indiquer un sous-répertoire du répertoire courant, utilise qc. comme <code>file.path (".", "textes")</code>.
 
Enfin, on peut aussi utiliser une syntaxe symple de type "Unix": <code>D:/data/exemples/txt</code>. Les "/" marchent sous Unix, Mac et Windows, les "\" ne marcheront pas tels quels.
 
'''Exemple: Lire plusieurs fichiers "text" dans un corpus'''
 
Voici un exemple plus concret pour Unix. Quelques documents, c-a-d. des fichiers *.text/txt simples, se trouvent dans un répertoire <code>/home/schneide/schneide/methodo/R/ex</code>. On va les importer dans un corpus "tm".
 
On vérifie le working directory et on charge la bibliothèque tm
<source lang="javascript">
getwd()
[1] "/home/schneide"
library(tm)
</source>
 
On définit le chemin:
<source lang="javascript">
archive_test <- file.path ("schneide", "methodo", "R", "ex")
</source>
 
On affiche les fichiers du répertoire:
<source lang="javascript">
dir (archive_test)
[1] "how-to-get-a-phd.text"                             
[2] "In-the-beginning-was-the-command-line-Stephenson.txt"
[3] "logic-and-qual-res.text" 
...
</source>
 
On crée un corpus
<source lang="javascript">
library(tm)
corpus.source <- Corpus(DirSource(archive_test))
</source>
 
On examine le corpus
<source lang="javascript">
# short summary information
show (corpus.source)
print (corpus.source)
<<VCorpus (documents: 6, metadata (corpus/indexed): 0/0)>>
</source>
 
On peut aussi examiner des détails
<source lang="javascript">
#Affiche tout (inutile, car trop)
inspect(corpus.source)
# Afficher le premier document,
inspect(corpus.source[1])
</source>
 
=== Lire du PDF et du WORD ===
 
Il existe des filtres (readers) pour ces 2 types de documents (pas testés). A tester: il est possible qu'il vaut mieux enregistrer Word comme PDF et ensuite utiliser le filtre PDF.
 
'''Installation de xpdf'''
 
Sous Windows:
* Téléchargez l'archive zip de sourceforge ([http://sourceforge.net/projects/xpdf.mirror/ download])
* Dézippez et copiez soit les fichiers 32bit, soit les 64 bit dans un répertoire. Je conseille <code>c:\soft\xpdf</code>. Donc après l'opération vous devriez y voir 9 fichiers, dont ''pdftotext.exe''.
* Editez le chemin d'exécutables de Windows et ajoutez ce répertoire. Lire [[Fichier_de_commande]] si vous ne savez pas le faire.
* Finalement, dans notre installation il manquait jpeg8.dll. On a copié/collé un fichier trouvé dans l'installation de [[Créer des e-book avec Calibre|calibre]] dans ce répertoire ....
 
 
Résumé de la syntaxe:
<source lang="matlab">
chemin <- file.path ("...")
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readDOC)) 
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readPDF))
</source>
 
Exemple:
<source lang="matlab" enclose="div">
library(tm)
# CHANGEZ ICI si nécessaire
# setwd ("./R")
# setwd("/home/schneide/schneide/methodo/R")
setwd("s:/methodo/R")
getwd()
archive_test <- file.path (".", "PDF")
dir (archive_test)
corpus.source_de_PDF <- Corpus(DirSource(archive_test), readerControl=list (reader=readPDF))
show (corpus.source_de_PDF)
# A la fin de ces fichiers il y a un form feed (ctrl-L)
# qu'on devrait éliminer. \r représente ce caractère
for (j in seq (corpus.source_de_PDF)) {
  corpus.source_de_PDF[[j]] <- gsub ("\r","", corpus.source_de_PDF[[j]])
}
inspect (corpus.source_de_PDF[1])
# On écrit les fichiers txt dans un répertoire. Facilite la vérification.
writeCorpus(corpus.source_de_PDF, path="./PDF_txt")
 
</source>
 
=== Aspirer des pages web ===
 
Il existe plusieurs méthodes et libraries pour lire des pages web. Selon le type de de besoin on peut travailler avec les fonctions R "standardes" ou avec des bibliothèques ou une combinaison des deux. Une fois qu'on a constitué un corpus, il faut "nettoyer" les textes, voir le chapitre suivant.
 
==== Création d'un corpus avec tm ====
 
Les fonctions "Corpus" du paquet tm permettent de lire des URLs (voir les exemple Mediawiki ci-dessous).
 
Principe:
* On définit une liste d'URLS et on la donne comme paramètre à la fonction Corpus
<source lang="matlab">
liste_URLs <- c("http://tecfa.unige.ch", "http://unige.ch/")
#On construit le corpus
Corpus.brut <- Corpus(URISource(list_URLs), readerControl = list(language="fr"))
</source>
 
==== La librairie tm.plugin.webmining ====
 
On conseille d'installer le paquet [http://cran.r-project.org/web/packages/tm.plugin.webmining/tm.plugin.webmining.pdf tm.plugin.webmining] car il combine l'aspiration avec des filtres HTML/XML et des fonctions toutes prêtes pour analyses des contenus qui viennent de Reuters, Yahoo, etc. Ce plugin nécessite également les paquets "XML" et "CURL" et qui seront installés automatiquement si tout va bien.
* Ce package nécessite Java, probablement une version de développement. Sous Unix il faut aussi dire à R où Java se trouve (sous root)
* Sous Win8, le package s'installe sans problème, mais ne trouve pas Java (Win8). Il faut soit bricoler les chemins d'environnement soit (plus facile) installer Java JDK, donc le kit de développement.
 
Dans une console Linux (sous root), pour indiquer l'emplacement de Java, taper:
:<code>sudo R CMD javareconf</code>.
 
Dans Linux, il faut également installer ''préalablement'' des '''bibliothèques de développement''' Curl et XML, sinon vous allez recevoir des messages d'erreurs comme <code> ERROR: configuration failed for package ‘RCurl’</code>, <code>rm: cannot remove 'a.out.dSYM': Is a directory</code>
:<code>sudo apt-get install libcurl4-openssl-dev</code>
:<code>sudo apt-get install libxml2-dev</code>
 
Ensuite, on peut installer le paquet. Alternativement, utilisez la facilité "Install" de RStudio.
:<code> install.packages("tm.plugin.webmining")</code>
 
Il existe d'autres logiciels de web scraping (trois sont listés dans la [http://cran.r-project.org/web/packages/tm.plugin.webmining/vignettes/ShortIntro.pdf vignette R Short Introduction to tm.plugin.webmining]. Il faut envisager d'utiliser ces outils externes lorsque vous téléchargez des gros volumes.
 
Charger la bibliothèque
:<code>library("tm.plugin.webmining")</code>
 
On peut assez facilement enregistrer une page web. La solution pour débutant est un simple "save as". Par contre il est moins simple d'éliminer les contenus inutiles (menus, etc). Donc déjà pour commencer, il faut chercher a télécharger une version "print".
 
Le package tm.plugin-webmining contient un certain nombre de fonctions utiles, et notamment:
extractContentDOM (url, threshold, asText ...)
* ''url'' définit la source, par exemple une URL
* ''theshold'' définit une sorte de "force" de filtrage de div's inutiles
* ''asText'' est une variable booléenne, mettre à FALSE pour un URL
 
Examples:
# threshold pour une page classique
test1 <- extractContentDOM("http://tecfa.unige.ch",0.1,FALSE)
# threshold qui marche pour edutechwiki
test2 <- extractContentDOM("http://edutechwiki.unige.ch/fr/Happy_Night",0.5,FALSE)
# identique à test2
test3 <- extractContentDOM("http://edutechwiki.unige.ch/fmediawiki/index.php?title=Happy_Night&printable=yes",0.5,FALSE)
 
==== Avec la bibliothèque XML ====
 
Selon les explications de [http://www.r-bloggers.com/reading-html-pages-in-r-for-text-processing/ Reading HTML pages in R for text processing], par Luis, 2011
 
* htmlTreeParse permet de lire une page HTML
* On peut ensuite extraire des listes de paragraphes basés sur une balise
 
<source lang="JavaScript">
library(XML)
doc = htmlTreeParse("http://tecfa.unige.ch/", useInternal=TRUE)
# Extraction des contenus des balises p, li, h1 et td
doc2 = unlist(xpathApply(doc, "//p|//li|//h1|//td", xmlValue))
# Virer les retour de lignes et tabs \n\t
doc3 = gsub('\\n', ' ', doc2)
doc3 = gsub('\\t', ' ', doc3)
# Joindre tout dans un seul string
doc.text = paste(doc3, collapse = ' ')
</source>
 
=== Créer un corpus avec des pages MediaWiki ===
 
Selon les besoins d'analyse on choisira une ou une autre méthode pour lire des pages Mediawiki. Il nous semble qu'il est préférable d'utiliser la méthode "XML" expliquée dans la sous-section suivante.
 
'''Utilisation de fonctions R de base pour lire dans des vecteurs'''
: Cette méthode marchera avec n'importe quelle page HTML.
<source lang="matlab">
library(tm)
library(stringi)
library(proxy)
# le nom du wiki
wiki <- "http://edutechwiki.unige.ch/fr/"
# une liste de noms de pages
titles <- c("STIC:STIC_I_-_exercice_1_(Utopia)", "STIC:STIC I - exercice 1 (Nestor-Pixel)",
            "STIC:STIC_I_-_exercice_2_(Utopia)",
            "STIC:STIC III (2012)/Module 1",  "STIC:STIC III (2012)/Module 2")
 
# un vecteur qui contient 5 strings vides ("")
articles <- character(length(titles))
 
# lecture des contenus des pages wiki. Chaque article se trouvera dans un des string ci-dessous.
for (i in 1:length(titles)) {
    articles[i] <- stri_flatten(readLines(stri_paste(wiki, titles[i])), col = "")
}
 
# Création d un corpus avec les articles
docs <- Corpus(VectorSource(articles))
</source>
 
'''Aspirer les pages en HTML brut avec tm'''
 
(ne semble pas marcher sous Linux, OK sous Windows)
 
<source lang="bibtex">
library(tm)
#Une longue procédure pour avoir une liste d'articles dans un string
wiki <- "http://edutechwiki.unige.ch/fr/"
titles <- c("Activate", "Cité romaine", "Citéjob-négo", "Darfur is dying",
            "Eonautes", "FacteurAcademy", "Happy Night", "InfinITy",
            "J'apprends J'entreprends", "Mon entretien d'embauche",
            "Timeout", "Tree Frog")
# un vecteur qui contient 12 strings vides ("")
article_list <- character(length(titles))
# on remplace par les URLs ci-dessus
for (i in 1:length(titles)) {
  article_list[i] <- (paste (wiki,titles[i], sep=""))
}
#Vérification
article_list
 
#On construit le corpus
# wiki.source <- URISource(article_list)
wiki.source <- Corpus(URISource(article_list), readerControl = list(language="fr"))
# Vérification
wiki.source
 
#Inspecter le corpus
inspect(VCorpus(wiki.source))
</source>
 
=== Méthode "XML" pour Mediawiki ===
 
Les MediaWiki ont une API qui autorise l'extraction de contenus de pages sans les textes qui font partie des menus. Un bon exemple est ce wiki. On peut afficher son API:
: http://edutechwiki.unige.ch/fmediawiki/api.php
Cette montre quel type d'informations on peut exporter facilement
 
Nous allons nous intéresser à l'extraction du contenu d'une page sous format XML. Il va aussi falloir la nettoyer, mais moins qu'avec les méthodes qui lisent toute la page ou qui se basent sur des algorithmes de détection du corps. Voici un exemple:
: http://edutechwiki.unige.ch/fmediawiki/api.php?action=parse&page=Civilization&format=xml
 
Le script R ci-dessous fait l'extraction d'un ensemble de pages crées par des étudiants dans le cadre d'un [[:Catégorie:Maltt VIP Tetris|cours sur la conception de jeux sérieux]].
<source lang="matlab">
library(tm)
#Une longue procédure pour avoir une liste d'URLs d'articles wiki dans un string
url_start <- "http://edutechwiki.unige.ch/fmediawiki/api.php?action=parse&page="
url_end <- "&format=xml"
titles <- c("Activate", "Cité romaine", "Citéjob-négo", "Darfur is dying",
            "Eonautes", "FacteurAcademy", "Happy Night", "InfinITy",
            "J'apprends J'entreprends", "Mon entretien d'embauche",
            "Timeout", "Tree Frog")
# un vecteur qui contient 12 strings vides ("")
article_list <- character(length(titles))
# on remplace par les URLs ci-dessus
for (i in 1:length(titles)) {
  article_list[i] <- (paste (url_start,titles[i],url_end, sep=""))
}
#Vérification
article_list
 
# On construit le corpus en utilisant un reader fait par nous et
# extrait juste l'élément "text"
readMWXML <-
  readXML (spec = list (content = list ("node", "//text"),
                        category = list ("node", "//categories/cl")
                        ),
                        doc=PlainTextDocument())
 
wiki.source <- Corpus(URISource(article_list, encoding="UTF-8"),
                      readerControl=list(reader=readMWXML)
                    )
 
#Inspecter le corpus
wiki.source
inspect(wiki.source)
inspect(wiki.source[1])
 
#Avant d'enregistrer (pas nécessaire),
# il faut changer les "id" sinon on obtient des noms de fichiers illégaux
for (j in seq.int (wiki.source)) {
  meta(wiki.source[[j]],"id") <- titles[j]
}
writeCorpus(wiki.source, path="./wiki_txt")
</source>
 
On a maintenant une série de documents "bruts" qui incluent le "corps" d'une page wiki et qu'il va falloir nettoyer. Voici le début d'un fichier
<source lang="HTML5" enclose="div">
<div style="border:1px solid grey;background-color:#FFAABB;padding:7px; margin-bottom: 10px;">
<p style="text-align:center;font-weight:bold;">
Page  réalisée dans le cadre du cours <a rel="nofollow" class="external text" href="http://vip-tetris.mixxt.com/">Jeux Vidéo Pédagogiques (VIP)</a><br /> (volée  "Tetris" 2013-2014) de la formation <a rel="nofollow" class="external text" href="http://tecfalabs.unige.ch/maltt/master/qui-sommes-nous/">maltt</a>, au <a rel="nofollow" class="external text" href="http://tecfa.unige.ch/">TECFA</a>.</p>
<p style="text-align:center;font-weight:bold;">
Cette page est une ébauche en cours de réalisation. Ne pas citer.</p>
</div>
.....
</source>
 
On va réutiliser ces données dans le chapitre suivant.
 
== Transformations de Corpus "tm" ==
 
Il existe un certain nombre de fonctions qui permet de "nettoyer" le texte d'un Corpus. La construction </code><tm_map></code> permet de appliquer une transformation à l'ensemble des textes d'un corpus. Parfois les fonctions fournies par "tm" ne suffisent pas et on doit faire des calculs plus "manuels".
 
=== Les fonctions de transformation ===
 
Partant avec un corpus, appelé <code>corpus0</code>, on peut effectuer plusieurs opérations de transformation, par exemple:
 
; stripWhitespace()
: Enlève les blancs en trop
: <code>corpus1 <- tm_map(corpus0, stripWhitespace)</code>
 
; tolower();
: Met tous les mots en minuscules
: <code>corpus2 <- tm_map(corpus1, tolower)</code>
 
; removeWords(....),
: Enlever des mots
: Par exemple des stopwords en Anglais: <code>corpus3 <- tm_map(corpus2, removeWords, stopwords("english"))</code>
: ou en français: <code>corpus5 <- tm_map(corpus3, removeWords, stopwords("french"))</code>
: ou une liste explicite de mots: <code>xxx = tm_map(corpus2, removeWords, c("Daniel", "Kaspar", "TECFA"))</code>
 
; removePunctuation()
: Enlever les ponctuations
 
; removeNumber()
: Enlever des nombres
 
; stemDocument()
: Faire du stemming
<source lang="javascript">
  library(SnowballC)
  corpus9 = stemDocument(corpusx, language = meta(corpusx, "language"))
</source>
 
On peut obtenir cette liste des transformations de tm avec la fonction:
getTransformations()
 
Certaines manipulations doivent se faire avec d'autres paquets ou encore avec les fonctions de base de R. Notamment la substitution de caractères:
 
; Remplacer des caractères (merci à [http://onepager.togaware.com/TextMiningO.pdf Graham Williams])
<source lang="javascript">
for (j in seq (corpus0)) {
  corpus0[[j]] <- gsub ("/", " ", corpus0[[j]])
  corpus0[[j]] <- gsub ("@", " ", corpus0[[j]])
......
}
</source>
 
On peut aussi utiliser des expression régulières, par exemple une qui tue une balise XML/HTML dans un string.
gsub("<.*/>","",string)
Ceci dit, les regexp ne marchent pas très bien pour enlever des balises HTML. Il vaut mieux utiliser une fonction du plugin tm.plugin.webmining
wiki.clean <- tm_map (wiki.source, extractHTMLStrip, encoding="UTF-8")
 
=== Exemple EduTechWiki (suite) ===
 
L'exemple suivant transforme les textes d'un corpus qu'on a crée ci-dessus avec la méthode "XML".
 
<source lang="matlab">
library(tm)
library(tm.plugin.webmining)
 
#VOIR CI-DESSUS, il nous faut un corpus sous forme de simples vecteurs de caractères.
wiki.source


#---------- Transformer des pages wiki en listes de mots
* On conseille d'utiliser [[IraMuTec]]
# On va gaspiller de la mémoire, c-a-d créer un nouveau corpus pour chaque opération
# Avantage: On peut revenir plus facile, explorer des alternatives, etc.
 
# Tuer les balises. Attention à l'encodage !!
wiki.clean1 <- tm_map (wiki.source, extractHTMLStrip, encoding="UTF-8")
 
# Alternative
# for (j in seq.int (wiki.source)) {
#  wiki.source[[j]] <- extractHTMLStrip(wiki.source[[j]])
# }
 
# Une expression régulière simple ne trouve qu'un élément: inutile
# for (j in seq.int (wiki.source)) {
#  wiki.source[[j]] <- gsub("<.*/>","",wiki.source[[j]])
# }
 
# Tuer les blancs, les ponctuations, les apostrophes du texte
# le mot "[modifier]", manque encore les URLs
 
wiki.clean2a <- tm_map (wiki.clean1, stripWhitespace)
 
# Replacing curly quotes does not work because it can't distinguish from straight quotes)
# Such behavior is not acceptable whatever the programmer's reasons could be.
# Anyhow, if you use some UTF-8 hex code it may work.
# U+2019 = ’
# \0xE2\0x80\0x98
for (j in seq.int (wiki.clean2a)) {
  wiki.clean2a[[j]] <- gsub("\u2019"," ",wiki.clean2a[[j]])
}
# test
wiki.clean2a[[5]]
 
for (j in seq.int (wiki.clean2a)) {
  wiki.clean2a[[j]] <- gsub("'"," ",wiki.clean2a[[j]])
}
 
for (j in seq.int (wiki.clean2a)) {
  wiki.clean2a[[j]] <- gsub("[«»”“\"]"," ",wiki.clean2a[[j]])
  wiki.clean2a[[j]] <- gsub("\\[modifier\\]"," ",wiki.clean2a[[j]])
}
 
# enlever les ponctuations qui restent
wiki.clean2b <- tm_map (wiki.clean2a, removePunctuation)
 
# encore une fois
wiki.clean2c <- tm_map (wiki.clean2b, stripWhitespace)
 
# Mettre tout en minuscules
wiki.clean3 <- tm_map (wiki.clean2c, tolower)
# Tuer les mots fréquents (stop words)
wiki.essence <- tm_map (wiki.clean3, removeWords, stopwords("french"))
 
# Extraire les racines. La bibliothèque SnowballC doit être installée.
getStemLanguages()
wiki.racines <- tm_map (wiki.essence, stemDocument, language="french")
wiki.racines <- tm_map (wiki.racines, stripWhitespace)
 
 
 
</source>
 
== Méthodes d'analyse ==
 
=== Analyses simples avec des matrices documents-termes ===
 
==== Créer des matrices ====
 
Une matrice documents-termes (Angl: Document Term Matrix (DTM) liste la fréquence de mots par document. Il existe deux variantes, un matrice "documents par termes" ou une matrice "termes par documents" comme c'est expliqué dans l'article [[text mining]].
 
Pour construire une matrice il faut utiliser soit <code>DocumentTermMatrix</code>, soit <code>TermDocumentMatrix</code>. Le corpus doit inclure les meta data qui on pu disparaître lors d'opérations de transformation, donc il faut les remettre comme ci-dessous
 
<source lang="matlab">
# Du Vodoo pour de nouveau créer un "vrai corpus"
wiki.mots <- Corpus(VectorSource(wiki.racines))
matrice_docs_termes <- DocumentTermMatrix(wiki.mots)
</source>
 
==== Reduction de la matrice ====
 
Notre matrice_termes_docs contient environ 2400 mots et que l'on pourra réduire
<source lang="matlab">
inspect(matrice_termes_docs)
</source>
 
<code>removeSparseTerms</code> enlève les mots que l'on retrouve dans moins de 40 et 60% des documents. Autrement dit, plus on réduit la proportion, moins on des mots.
<source lang="matlab">
inspect(removeSparseTerms(matrice_termes_docs, 0.4))
inspect(removeSparseTerms(matrice_termes_docs, 0.6))
</source>
 
Voilà les mots aimés par tous les auteurs ....
<source lang="matlab">
inspect(removeSparseTerms(matrice_termes_docs, 0.01))
<<TermDocumentMatrix (terms: 32, documents: 12)>>
Non-/sparse entries: 384/0
Sparsity          : 0%
Maximal term length: 12
Weighting          : term frequency (tf)
 
              Docs
Terms          1  2  3  4  5 6  7  8  9 10 11 12
  20132014      1  1  1  1  1 1  1  1  1  1  1  1
  cadre        1  1  1  1  4 1  1  1  1  6  3  1
  citer        1  1  1  1  1 1  1  2  1  1  1  1
  contenu      5 10  2  7  6 3  6  7  4  6  5  2
  cours        4  3  2  2  4 3  4  5  2  5  2  2
  description  2  2  2  2  2 2  3  2  2  5  3  2
  doit          5  6  2  1 16 2  8  8  2  5 10  9
  ébauche      1  1  1  1  1 1  1  1  1  1  1  1
  enseigné      4  8  2  4  6 2  5  5  3  2  5  2
  fait          3  8  1  1  1 1  3  1  2  4  3  2
  formation    1  1  1  1  1 3  1  1  1  1  1  1
  forts        4  3  2  2  4 2  4  4  3  4  4  4
  intégration  2  3  2  3  4 2  4  5  2  3  3  3
  jeu          37 38 14 20 26 8 46 50 33 69 29 14
  jeux          4 11  1  3  3 1  5  3  1  4  1  2
  joueur      33 15  1  2 35 2 22 25 13 23  1 22
  logiciels    2  2  2  2  2 2  3  4  4  2  2  4
  maltt        1  1  1  1  1 1  1  1  1  1  1  1
  page          2  2  2  2  2 2  4  2  2  4  2  2
  pédagogiques  3  5  3  3  3 3  4  3  3  5  3  4
  point        2  1  2  3  2 2  2  1  6  7  5  5
  points        6  6  2  3  6 2  9  6  5 12  4  6
  principes    2  2  2  3  3 2  2  2  3  3  3  3
  réalisation  1  1  1  1  1 1  1  1  1  1  1  1
  réalisée      1  1  1  1  1 1  1  1  1  1  1  1
  similaires    2  2  2  2  3 2  2  2  2  2  2  2
  sommaire      1  1  1  1  1 1  1  1  1  1  1  1
  tecfa        1  1  1  1  1 1  1  1  1  1  1  1
  tetris        1  1  1  1  1 1  1  1  1  1  1  1
  vidéo        1  1  1  1  1 1  2  3  1  3  2  1
  vip          1  1  1  1  3 1  1  1  1  1  1  1
  volée        1  1  1  1  1 1  1  1  1  1  1  1
</source>
 
Voici une liste de mots que l'on retrouve dans au moins 40% des documents:
<source lang="matlab">
Non-/sparse entries: 848/160
Sparsity          : 16%
Maximal term length: 13
Weighting          : term frequency (tf)
 
              Docs
Terms            1  2  3  4  5 6  7  8  9 10 11 12
  20132014      1  1  1  1  1 1  1  1  1  1  1  1
  accès          2  2  0  3  8 1  4  2  1  1  2  0
  actions        1  1  0  1  3 0  3  0  1  1  3  0
  agit          5  0  1  1  0 1  3  0  2  2  1  4
  ainsi          4  0  1  0  2 0  5  3  0  4  1  1
  apprentissage  6  8  0  0 11 0  1  4  1  4  4  5
  aussi          6  2  1  1  0 1  0  3  1  5  3  1
  avant          1  3  1  0  1 0  1  1  0  3  1  0
  bien          3  6  0  1  5 3  6  1  0  5  2  0
  but            6  1  0  0  2 0  4  1  1  3  1  3
  cadre          1  1  1  1  4 1  1  1  1  6  3  1
  cas            1  2  0  1  2 0  0  2  1  3  5  0
  certains      1  1  0  2  2 0  0  0  1  3  2  1
  chaque        3  1  0  0  5 2  3  8  3  1  0  1
  choisir        6  1  1  2  2 0  2  1  3  2  0  0
  choix          9  0  1  0  0 0 10  1  6  8  2  1
  citer          1  1  1  1  1 1  1  2  1  1  1  1
  comme          2  3  0  0  3 0 12  5  0 11  1  1
  connaissances  5  0  0  1  3 0  1  2  1  1  4  0
  contenu        5 10  2  7  6 3  6  7  4  6  5  2
  cours          4  3  2  2  4 3  4  5  2  5  2  2
  description    2  2  2  2  2 2  3  2  2  5  3  2
  deux          5  3  0  1  0 0  2  1  2 11  6  1
  différents    3  2  1  0  0 0  4  9  3  1  3  0
  doit          5  6  2  1 16 2  8  8  2  5 10  9
  donc          2  3  0  0  6 1  3  0  1  1  4  7
  ébauche        1  1  1  1  1 1  1  1  1  1  1  1
  écran          0  2  1  3  2 0  2  3  3  2  5  0
  enseigné      4  8  2  4  6 2  5  5  3  2  5  2
  entre          1  2  1  0  0 0  4  2  6  3  0  3
  environnement  4  2  0  1  3 1  1  1  1  3  2  0
  être          8  2  0  0  0 1  4  5  1  5  4  1
  exemple        8  5  0  1  4 1  7  6  3  6  4  2
  faibles        4  3  2  2  4 2  0  4  3  4  4  4
  faire          5  0  1  1  4 1  8  2  3  9  1  4
  fait          3  8  1  1  1 1  3  1  2  4  3  2
  faut          9  2  0  1  2 0  3  3  1  2  1  4
  feedback      0  7  0  0  5 0  6  3  2  7  9  4
  fin            3  0  0  0  5 1  4  5  1 11  1  1
  fois          3  4  3  0  0 0  2  4  2  4  2  1
  formation      1  1  1  1  1 3  1  1  1  1  1  1
  forts          4  3  2  2  4 2  4  4  3  4  4  4
  informatique  2  2  0  1  3 1  0  5  1  2  2  0
  intégration    2  3  2  3  4 2  4  5  2  3  3  3
  internet      2  1  0  1  2 0  0  1  1  1  0  1
  jeu          37 38 14 20 26 8 46 50 33 69 29 14
  jeux          4 11  1  3  3 1  5  3  1  4  1  2
  jouer          0  3  2  0  2 1  2  2  0  1  0  2
  joueur        33 15  1  2 35 2 22 25 13 23  1 22
  logiciels      2  2  2  2  2 2  3  4  4  2  2  4
  long          1  2  0  1  1 0  4  1  0  1  0  1
  lors          5  1  0  0  2 0  1  4  1  9  1  0
  maltt          1  1  1  1  1 1  1  1  1  1  1  1
  manière        2  5  1  0  6 0  2  1  0  0  1  2
  mécanique      2  3  0  3  4 2  9  4  2  7  3  0
  niveau        28  1  0  2  2 0  3  8  3  0  3  1
  objectif      2  2  0  1  1 1  3  2  2  7  0  2
  page          2  2  2  2  2 2  4  2  2  4  2  2
  passer        1  2  0  0  3 0  1  2  0  2  1  3
  pédagogique    4  9  1  3  1 0  0  2  1  2  1  3
  pédagogiques  3  5  3  3  3 3  4  3  3  5  3  4
  permet        2  1  0  0 10 0  2  6  4  2  1  4
  personne      2  0  1  0  1 0  2  1  3  2  1  0
  peut          4 11  1  2 12 0  4  5  4 17  4  3
  plus          11 11  2  0  4 0  9  2  1 13  2  5
  point          2  1  2  3  2 2  2  1  6  7  5  5
  points        6  6  2  3  6 2  9  6  5 12  4  6
  possible      5  1  1  0  3 0  2  1  0  1  1  1
  prendre        0  2  1  0  2 1  2  1  1  1  0  0
  principes      2  2  2  3  3 2  2  2  3  3  3  3
  quelques      1  3  1  0  2 0  1  2  0  2  0  1
  réalisation    1  1  1  1  1 1  1  1  1  1  1  1
  réalisée      1  1  1  1  1 1  1  1  1  1  1  1
  similaires    2  2  2  2  3 2  2  2  2  2  2  2
  sommaire      1  1  1  1  1 1  1  1  1  1  1  1
  sous          1  2  1  1  0 2  2  5  0  7  1  1
  tecfa          1  1  1  1  1 1  1  1  1  1  1  1
  temps          1  3  0  3  7 1  1  0  0  2  8  0
  tetris        1  1  1  1  1 1  1  1  1  1  1  1
  tout          2  7  1  4  4 0  6  1  0  3  2  3
  type          0  1  0  0  1 0  1  1  2  1  1  2
  vidéo          1  1  1  1  1 1  2  3  1  3  2  1
  vip            1  1  1  1  3 1  1  1  1  1  1  1
  volée          1  1  1  1  1 1  1  1  1  1  1  1
</source>
 
==== Visualisation d'une matrice termes-documents ====
 
La matrice suivante donne la même vision que ci-dessus, mais avec un graphique. Enfin pour augmenter la lisibilité on baissé le seuil de mots à montrer à la présence d'au moins 80% des documents (0.2 = absent dans moins que 20%).
 
Pour créer ces visualisations, on ne peut pas utiliser les données brutes (enfin j'imagine qu'il doit bien exister une bibliothèque pour cela). A la place on fait une transformation qui nous ramène à des valeurs < 1 et qui représentent le "poids" d'un terme comme expliqué dans l'article [[text mining]]. Mais attention, on ne s'est pas documenté sur l'algorithme (weightTf) utilisé, il y a peut-être mieux à faire....
<source lang="matlab">
# Créer une DTM avec des poids normalisées
mtd.norm <- as.matrix(removeSparseTerms(
  TermDocumentMatrix(wiki.mots, control=list(weighting=weightTf)),
  0.2))
corrplot (mtd.norm, is.corr=FALSE)
</source>
[[Fichier:Plot dtm matrix2.png|500px|vignette|néant|Plot "Weighted term-document matrix by term frequency"]]
On voit que le mot "jeu" domine largement "le débat" dans tous les textes. Pour mieux faire ressortir les autres distributions, on peut '''soit''' éliminer ces mots, '''soit utilisé une autre matrice qui donne moins de poids au termes fréquents et ommnipreésents''', soit les deux.
 
Ci-dessous on utilise un style de "programmation" plus dense.
* La matrice termes-documents est est transformé en matrice termes-documents "weighted" selon la méthode TfIdf expliquée dans [[Text mining]] (la fréquence du terme dans un document pondéré par la fréquence du terme dans le corpus)
* Pour finir, on l'a épuré de tous les mots qui se trouvent dans moins de 40% de documents.
<source lang="matlab">
# Créer une DTM avec des poids TFIdf
mtd.TfIdf <- as.matrix(
  removeSparseTerms(
    TermDocumentMatrix(
      tm_map(wiki.mots),
      control=list(weighting=weightTfIdf)
    ),
    0.4)
</source>
[[Fichier:Plot dtm matrix4.png|600px|vignette|néant|Plot "Weighted term-document matrix by term frequency"]]
On observe que le mot "jeu" a disparu. Etant donné qu'il existait dans chaque document il n'était pas discriminant.
 
Ci dessous, on montre comment manuellement enlever des mots.
<source lang="matlab">
# Créer une DTM avec des poids TFIdf et sans 3 mots
mtd.norm_sans <- as.matrix(
  removeSparseTerms(
    TermDocumentMatrix(
      tm_map(wiki.mots, removeWords, c("jeu", "jeux", "joueur")),
      control=list(weighting=weightTfIdf)
    ),
    0.4)
)
corrplot (mtd.norm_sans, is.corr=FALSE)
</source>
[[Fichier:Plot dtm matrix3.png|600px|vignette|néant|Plot "Weighted term-document matrix by term frequency"]]
Voici encore une fois une matrice TFIdf plus petite seuil = 20%
<source lang="matlab">
library(corrplot)
mtd.TfIdf2 <- as.matrix(removeSparseTerms(
  TermDocumentMatrix(wiki.mots, control=list(weighting=weightTfIdf)),
  0.2))
# Plot simple
corrplot (mtd.TfIdf2, is.corr=FALSE)
</source>
 
[[Fichier:Plot dtm matrix5.png|500px|vignette|néant|Plot "Weighted term-document matrix by term frequency - inverse document frequency"]]
 
==== Tableaux de termes fréquents ====
 
Rappelons que nos textes on été épurés (pas de stop words, des racines). Ceci dit, il nous semble que le "stemming" ne marche pas bien (à vérifier pourquoi). Le code suivant liste tous les mots qui sont utilisé au moins 30 fois.
<source lang="matlab">
findFreqTerms(matrice_docs_termes, 30)
</source>
Résultat:
<source lang="matlab">
[1] "apprentissage" "bien"          "choix"        "comme"       
[5] "contenu"      "cours"        "deux"          "doit"       
[9] "enseigné"      "être"          "exemple"      "faibles"     
[13] "faire"        "fait"          "feedback"      "fin"         
[17] "forts"        "intégration"  "jeu"          "jeux"       
[21] "joueur"        "logiciels"    "mécanique"    "mission"     
[25] "niveau"        "pédagogiques"  "permet"        "peut"       
[29] "plus"          "point"        "points"        "principes"   
[33] "tout"          "utilisateur"
</source>
 
==== Associations mot avec un mot ====
 
Quels mots sont utilisés souvent avec "feedback" dans un document ?
 
<source lang="matlab">
# find associations with a word
findAssocs(matrice_termes_docs, "feedback", 0.8)
            feedback
explication    0.84
haut            0.83
milieu          0.80
 
findAssocs(matrice_termes_docs, "feedback", 0.7)
            feedback
explication    0.84
haut            0.83
milieu          0.80
premier        0.77
car            0.76
expérience      0.76
etc            0.71
travers        0.71
</source>
 
=== Corroboration des lois de Zipf et de Heap ===
 
Lire:
* [http://fr.wikipedia.org/wiki/Loi_de_Zipf La loi de Zipf] (Wikipedia)
* [http://en.wikipedia.org/wiki/Heaps%27_law Heaps Law] (Wikipedia/en)
 
<source lang="matlab">
Zipf_plot(matrice_termes_docs)
(Intercept)          x
  6.6338162  -0.8466039
</source>
[[Fichier:Zipf plot.png|cadre|néant|Zipf plot d'un corpus de fiches sur les jeux pédagogiques]]
<source lang="matlab">
Heaps_plot(matrice_termes_docs)
(Intercept)          x
  0.9737307  0.7676657
</source>
[[Fichier:heaps plot.png|cadre|néant|Heaps plot d'un corpus de fiches sur les jeux pédagogiques]]
 
=== Word Clouds ===
 
Les words clouds peuvent utiliser des palettes.
 
<source lang="matlab">
# Afficher les palettes des couleurs pour pouvoir mieux choisir
display.brewer.all()
</source>
[[Fichier:Brewer-palette.png|none|cadre|Palettes du brewer]]
 
La fonction <code>wordcloud(...)</code> de la bibliothèque '''wordcloud''' permet de créer des wordcloud en utilisant plusieurs paramètres, par exemple:
 
; scale=''vecteur avec 2 nombres''
: Définit l'empan de la taille des mots (plus grand/ plus petit)
; min.freq = ''nombre''
: Définit un seul de fréquence. Au-dessous les mots sont éliminés
; colors = liste de couleurs
: du plus fréquent au moins fréquent
; max.words = ''nombre''
: Max. mots à afficher. Les moins fréquents sont éliminés.
; vfont=c("''nom''","''variante''"))
: définit la fonte.
 
Ci-dessous on crée plusieurs words clouds pour des documents invidiuels
<source lang="matlab">
# Wordclouds
library(wordcloud)
wordcloud(wiki.racines[[5]],
          scale=c(5,0.1), rot.per=0.35,
          min.freq=3, use.r.layout=FALSE,
          colors= brewer.pal(8,"Spectral")
          )
wordcloud(wiki.racines[[8]],
          scale=c(5,0.1), rot.per=0.35,
          min.freq=3, use.r.layout=FALSE,
          colors= brewer.pal(8,"Spectral")
)
wordcloud(wiki.racines[[9]],
          scale=c(5,0.1), rot.per=0.35,
          min.freq=3, use.r.layout=FALSE,
          colors= brewer.pal(8,"Spectral")
)
wordcloud(wiki.racines[[3]],
          scale=c(5,0.1), rot.per=0.35,
          min.freq=3, use.r.layout=FALSE,
          colors= brewer.pal(8,"Spectral")
)
</source>
 
[[Fichier:Word cloud fiche jeu.png|cadre|néant|Word cloud d'une fiche (page wiki) sur un jeu pédagogique]]
 
Ci-dessous des clouds qui résument et comparent à travers le corpus
<source lang="matlab">
#Communality clouds
 
mtd <- as.matrix(matrice_termes_docs)
comparison.cloud(mtd,random.order=FALSE,
                scale=c(5,0.5), rot.per=0.35,
                max.words=50, use.r.layout=FALSE,
                colors= brewer.pal(8,"Spectral")
)
commonality.cloud(mtd,random.order=FALSE,
                  scale=c(5,0.5), rot.per=0.35,
                  max.words=50, use.r.layout=FALSE,
                  colors= brewer.pal(8,"Spectral")
)
</source>
 
Etant donne que le mot "jeu" domine trop, on pourrait l'éliminer
<source lang="matlab">
#Without the "jeu"
 
wiki.sans_jeu <- tm_map(wiki.mots, removeWords, c("jeu", "jeux"))
mtd2 <- TermDocumentMatrix(wiki.sans_jeu)
mtd2 <- as.matrix(mtd2)
commonality.cloud(mtd2,random.order=FALSE,
                  scale=c(2,0.5), rot.per=0.35,
                  max.words=50, use.r.layout=FALSE,
                  colors= brewer.pal(8,"Spectral")
)
</source>
[[Fichier:commonality_word_cloud.png|cadre|néant|Word cloud commune d'un corpus]]
 
== Construction d'indices avec korpus ==
 
Voir [[Tutoriel koRpus]]
 
Korpus est une autre bibliothèque d'analyse de textes populaire. Pas compatible avec rm, elle se spécialise sur la construction d'indices à partir d'une représentation linguistique de textes.
 
Pour l'installer:
* 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.
 
== Analyses avec IraMuTec ==
 
[http://www.iramuteq.org/ Iramutec] est un logiciel (Interface de R) qui permet de faire un certain nombre d'analyses statistiques relativement facilement. On peut considérer que ce logiciel est une implémentation open source des fonctionnalités populaires du logiciel commercial [http://www.image-zafar.com/ Alceste] et de la méthode ALCESTE ("Analyse des Lexèmes Cooccurrents pour un Ensemble de Segmentations du Texte en Énoncés") sous-jacent développée par Max Reinert.


Selon le [http://www.image-zafar.com/fr/logiciel-alceste site officiel],  {{citation|Alceste, à partir d’un corpus, effectue une première analyse détaillée de son vocabulaire, et constitue le dictionnaire des mots ainsi que de leur racine, avec leur fréquence. Ensuite, par fractionnements successifs, il découpe le texte en segments homogènes contenant un nombre suffisant de mots, et procède alors à une classification de ces segments en repérant les oppositions les plus fortes. Cette méthode permet d’extraire des classes de sens, constituées par les mots et les phrases les plus significatifs, les classes obtenues représentent les idées et les thèmes dominants du corpus. L’ensemble des résultats triés selon leur pertinence, accompagnés de nombreuses représentations graphiques et de différents rapports d’analyse, permet à l’utilisateur une interprétation aisée et efficace.}}
Selon le [http://www.image-zafar.com/fr/logiciel-alceste site officiel],  {{citation|Alceste, à partir d’un corpus, effectue une première analyse détaillée de son vocabulaire, et constitue le dictionnaire des mots ainsi que de leur racine, avec leur fréquence. Ensuite, par fractionnements successifs, il découpe le texte en segments homogènes contenant un nombre suffisant de mots, et procède alors à une classification de ces segments en repérant les oppositions les plus fortes. Cette méthode permet d’extraire des classes de sens, constituées par les mots et les phrases les plus significatifs, les classes obtenues représentent les idées et les thèmes dominants du corpus. L’ensemble des résultats triés selon leur pertinence, accompagnés de nombreuses représentations graphiques et de différents rapports d’analyse, permet à l’utilisateur une interprétation aisée et efficace.}}

Version du 25 novembre 2014 à 14:16

Tutoriels R
▲
◀▬
⚐ ☸
⚒ 2014/11/25
Prérequis

Cet article est une ébauche à compléter. Une ébauche est une entrée ayant un contenu (très) maigre et qui a donc besoin d'un auteur.

A faire (ceci est vraiment un brouillon, la lecture de ce texte peut détruire votre ordinateur)

  • tout réviser et vérifier !!
  • splitter la page en 3-4 sujets
  • fournir du code compact pour des tâches typiques

- Daniel K. Schneider (discussion) 8/24 oct. 2014

Introduction

A faire ....

Sources de données utilisées dans les exemples

R et ses extensions permettent de digérer des formats de documents divers. Dans nos examples, nous allons nous concentrer sur:

Survol de paquets R

Il existe plusieurs paquets utiles pour effectuer des analyses exploratoires de textes. Ces paquets s'installent en règle générale assez facilement. Si vous utilisez R-Studio il suffit de cliquer l'onglet "Install" et taper le nom. Ceci dit, il faut parfois installer d'autres langages comme Java. Sur PC les paquets sont déjà compilés, sous Linux ils sont compilés (ce qui implique qu'il faut avoir installé C, Fortran, Perl, Java, etc.)

Il n'est pas nécessaire de lire cela lors de votre première visite (....)

Utilitaires

  • stringi (permet de manipuler des chaines de caractères)
  • XML (manipulation de fichiers XML/HTML)
  • tau (régler l'encodage, tokeniser, compter)

Text mining paquets à vocation multiple

Ces paquets sont conçus différemment. Certains offrent des analyses de A-Z alors que d'autres offrent surtout un soutien pour toutes les étapes de préparation

tm
tm est un "framework" pour l'analyse de texte. Le logiciel aide pour tout ce qui est préparation, constitution de corpus, analyses simples (fréquences, etc.). On peut construire des tableaux de proximité que l'on peut ensuite analyser avec des outils statistiques.
Voir Tutoriel tm text mining package
Cran.r: tm: Text Mining Package
Home page
Rdocumentation: tm
Il existe des extensions (voir ci-dessous pour certains)
tm.plugin.mail
Permet d'analyser des fichiers emails
tm.plugin.webmining
Inclut des fonctions "web scraping"
tm.plugin.alceste
Permet d'importer des fichiers au form "Aleceste" (voir par exemple IRaMuTeQ)
qdap
Grand éventail d'outils pour analyser des transcriptions (entretiens, dialogues, etc.) , mais on peut l'utiliser pour d'autres types de textes
cran.r: qdap: Bridging the Gap Between Qualitative Data and Quantitative Analysis
home page (sur GitHub)
Rdocumentation: qdap
Description: qdap automates many of the tasks associated with quantitative discourse analysis of transcripts containing discourse including frequency counts of sentence types, words, sentences, turns of talk, syllables and other assorted analysis tasks. The package provides parsing tools for preparing transcript data. Many functions enable the user to aggregate data by any number of grouping variables, providing analysis and seamless integration with other R packages that undertake higher level analysis and visualization of text. [...]
RcmdrPlugin.temis
cran.r: RcmdrPlugin.temis: Graphical Integrated Text Mining Solution
RcmdrPlugin.temis
Homepage (sur R-Forge)
Description: An R Commander plug-in providing an integrated solution to perform a series of text mining tasks such as importing and cleaning a corpus, and analyses like terms and documents counts, vocabulary tables, terms co-occurrences and documents similarity measures, time series analysis, correspondence analysis and hierarchical clustering. Corpora can be imported from spreadsheet-like files, directories of raw text files, Twitter queries, as well as from Dow Jones Factiva, LexisNexis, Europresse and Alceste files.
koRpus
Comprend plusieurs outils, notamment des opérations de bases, des indices populaires de "readabilité" et de diversité, une interface avec TreeTagger
cran.r: koRpus: An R Package for Text Analysis
Homepage
koRpus
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.
textometrieR
Ne semble pas bien marcher dans R 3.1.1 (dernière mise à jour 2009, manque des choses ?)
Description: Statistical exploration of textual corpora using several methods from french 'lexiometrie' and french 'Data Analysis' schools. It includes methods for exploring irregularity of distribution of lexicon (or other features) accross parts of texts; multidimensionnal exploration ('Analyse des correspondances'), etc.
textometrie
Other version of the above ?
Description: Statistical exploration of textual corpora using several methods from French 'Textometrie' (new name of 'Lexicometrie') and French 'Data Analysis' schools. It includes methods for exploring irregularity of distribution of lexicon features across text sets or parts of texts (Specificity analysis); multi-dimensional exploration (Factorial analysis), etc. Those methods are used in the TXM software.

Analyses spécifiques

mallet
apprentissage machine, utile pour topic modeling
il s'agit d'une interface pour le programme Java "Mallet"
Rdocumentation: mallet
lda
fonctionalités similaires à mallet
Rdocumentation: lda
Description: This package implements latent Dirichlet allocation (LDA) and related models. This includes (but is not limited to)sLDA, corrLDA, and the mixed-membership stochastic blockmodel [...]
sentiment
analyse de sentiments
Rdocumentation: sentiment
Pas disponibles dans R 3.1.1 ?
RTextTools
classification automatique de textes, 9 méthodes à choix
RDocumentation: RTextTools
Description: RTextTools is a machine learning package for automatic text classification that makes it simple for novice users get started with machine learning, while allowing experienced users to easily experiment with different settings and algorithm combinations. The package includes nine algorithms for ensemble classification (svm, slda, boosting, bagging, random forests, glmnet, decision trees, neural networks, maximum entropy), comprehensive analytics, and thorough documentation.
lsa (latent semantic analysis)
Permet de mener des analyses de type LSA
RDocumentation: lsa
Description: The basic idea of latent semantic analysis (LSA) is, that text do have a higher order (=latent semantic) structure which, however, is obscured by word usage (e.g. through the use of synonyms or polysemy). By using conceptual indices that are derived statistically via a truncated singular value decomposition (a two-mode factor analysis) over a given document-term matrix, this variability problem can be overcome.
RWeka
Interface R pour le logiciel Weka (écrit en Java). Weka semble être l'outil le plus populaire en text mining combiné au machine learning (par exemple pour classifier des segments)
RDocumentation: Rweka
Description: An R interface to Weka (Version 3.7.11). Weka is a collection of machine learning algorithms for data mining tasks written in Java, containing tools for data pre-processing, classification, regression, clustering, association rules, and visualization

Paquets statistiques

maxent
classification automatique de textes avec "maximum entropy" ak multinomial logistic regression

Description: maxent is an R package with tools for low-memory multinomial logistic regression, also known as maximum entropy. The focus of this maximum entropy classifier is to minimize memory consumption [..], particularly sparse document-term matrices represented by the tm package. [...]

proxy
analyses de proximités
Description: Provides an extensible framework for the efficient calculation of auto- and cross-proximities, along with implementations of the most popular ones.
ca
Description: A package for computation and visualization of simple, multiple and joint correspondence analysis.

....

Survol d'analyses

Préparation de documents

  • Pour préparer des "sacs de mots" nettoyés et pour fabriquer des tableaux de fréquences ou de proximité, on conseille d'utiliser tm

Analyses de type ALCESTE

Iramutec est un logiciel (Interface de R) qui permet de faire un certain nombre d'analyses statistiques relativement facilement. On peut considérer que ce logiciel est une implémentation open source des fonctionnalités populaires du logiciel commercial Alceste et de la méthode ALCESTE ("Analyse des Lexèmes Cooccurrents pour un Ensemble de Segmentations du Texte en Énoncés") sous-jacent développée par Max Reinert.

Selon le site officiel, «Alceste, à partir d’un corpus, effectue une première analyse détaillée de son vocabulaire, et constitue le dictionnaire des mots ainsi que de leur racine, avec leur fréquence. Ensuite, par fractionnements successifs, il découpe le texte en segments homogènes contenant un nombre suffisant de mots, et procède alors à une classification de ces segments en repérant les oppositions les plus fortes. Cette méthode permet d’extraire des classes de sens, constituées par les mots et les phrases les plus significatifs, les classes obtenues représentent les idées et les thèmes dominants du corpus. L’ensemble des résultats triés selon leur pertinence, accompagnés de nombreuses représentations graphiques et de différents rapports d’analyse, permet à l’utilisateur une interprétation aisée et efficace.»

Préparation du texte à analyser

Ce logiciel ne lit que des fichiers text nettoyés. Un texte ne peut pas contenir des "*". Il faut les préparer avec R par exemple.

Un corpus est un seul grand fichier et qui contient un balisage "Alceste" (introduit ci-dessous). On peut le créer de plusieurs façons, par exemple avec R ou manuellement.

Selon le manuel,

  • Les fichiers d'entrée doivent être au format texte brut (.txt), et de préférence contenir les caractères de ponctuations.
  • Dans ce formatage, l'unité de base est appelée « Texte ». Un texte peut représenter un entretien, un article, un livre ou tout autre type de documents. Un corpus peut contenir un ou plusieurs textes (mais au minimum un).

Dans le fichier corpus, les "textes" sont introduits par quatre étoiles (****) suivies d'une série de variables étoilées (variables illustratives) séparées par un espace. 

**** *prom_tetris *jeu_play-the-news *var_x-y
contenu du texte ....

**** *prom_tetris *jeu_TechnoCity
contenu du texte ....

A l'intérieur d'une section "texte", on peut aussi identifier des thématiques 

**** *prom_tetris *jeu_play-the-news *var_x-y
-*thematique1
contenu du texte .....
 -*thematique2
contenu du texte .....

Concatener tous les fichiers d'un répertoire sous Linux (devrait aussi marcher sur un Mac) 

 ls -aQ | xargs cat > corpus.txt

LSA

Packages:

  • irlba
  • clustrd

Adapter (si nécessaire) la DTM produit avec le paquet tm 

dtm.to.sm <->
 sparseMatrix(i=dtm$i, j=dtm$j, x=dtm$v,
              dims=c(dtm$nrow, dtm$ncol))
}

Topic Modeling

(à faire)

Liens

Articles d'introduction

  • Ingo Feiner (2014). Introduction to the tm Package Text Mining in R, http://cran.r-project.org/web/packages/tm/vignettes/tm.pdf
    • Official "vignette" (introductory text included with the package). Quote: “This vignette gives a short introduction to text mining in R utilizing the text mining framework provided by the tm package. We present methods for data import, corpus handling, preprocessing, metadata management, and creation of term-document matrices.”
  • Ingo Feinerer, Kurt Hornik, David Meyer (2008). Text Mining Infrastructure in R, Journal of Statistical software, Vol. 25, Issue 5, http://www.jstatsoft.org/v25/i05/ (open contents)
    • Article complet par les auteurs du package et qui introduit le paquet tm (version 2008). Il contient aussi des exemples.

Sites

Exemples et/ou textes informels

  • Text mining with R (slides) by Aleksei Beloshytski
    • Montre (superficiellement) notamment comment analyser un blog, c'est à dire extraire les contenus, puis extraire les thèmes les plus populaires, clustering, etc.

Statistiques

Q/A Stackoverflow

Lire du XML
HTML scraping
Récupérée de « https://edutechwiki.unige.ch/fmediawiki/index.php?title=Text_mining_avec_R&oldid=40844 »