Text mining avec R

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.

Voir aussi:

• R
• Text mining

Il faudrait diviser la page en:

• Concepts et survol d'outils (laisser ici)
• Analyses et/ou bibliothèques spécifiques à mettre ailleurs

- Daniel K. Schneider (discussion) 8 octobre 2014 à 14:48 (CEST)

Introduction

Il existe plusieurs paquets utiles pour effectuer des analyses exploratoires de textes

• tm (paquet text mining populaire)
• stringi (permet de manipuler des chaines de caractères)
• proxy (analyses de proximités)
• mallet (apprentissage machine, utile pour topic modeling)
• lda (similaire à mallet)
• XML (manipulation de fichiers XML/HTML)

Le paquet tm

tm est le paquet "text mining" les plus populaire de R et il faut l'installer si nécessaire.

Pour l'utiliser: library(tm)

Si nécessaire, installez ce paquet avec R-Studio ou tapez: install.packages("tm")

Importation de documents et corpus

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.

Le Corpus 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:

• VCorpus alias >code>Corpus (volatile, lorsqu'on arrête R, il faut reconstruire le corpos ...
• PCorpus (endroit unique où le corpus est stocké)

Syntaxe de Vcorpus:

Vcorpus(Objet source, 'reader)

par exemple:

VCorpus( DirSource(txt, encoding = "UTF-8"), readerControl = list(language = "fr") )

Pour construire un corpus, il faut donc donner deux arguments

1. Identifier un type de 'source de données: soit DataframeSource, DirSource, URISource, vectorSource ou XMLSource
2. Definir le reader, c-a-d. on manière dont le texte est lu avec readerControl, notamment readDOC, readPDF, readPlain, readXML, readTabular.

Le type de sources et de readers de votre installation R peut être affiché avec les commandes suivantes:

 getReaders() # affiche toute la liste de readers
 getSources() # affiche la liste des types de sources

Chaque source possède un lecteur (reader) par défaut. Par exemple pour DirSource, c'est readPlain.

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 system.file

# 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"))

Inspection et utilisation de corpus

Pour vérifier les contenus on peut afficher le tout ou encore juste quelques éléments, par exemple:

# print a short overview
print(ovid)

# show all
inspect(ovid)
ovid

# display the second document
ovid[[2]]

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.

# Afficher le répertoire de travail courrant
getwd()
[1] "C:/Users/dschneid/Documents"
# changer le répertoire de travail
setwd "C:/dks/R"

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 D:\data\exemples\txt, utilisez du code comme chemin <- file.path("d:", "data", "exemples", "txt") . Pour indiquer un sous-répertoire du répertoire courant, utilise qc. comme file.path (".", "textes").

Enfin, on peut aussi utiliser une syntaxe symple de type "Unix": D:/data/exemples/txt. Les "/" marchent sous Unix, Mac et Windows, les "\" ne marcheront pas tels quels.

Exemple

Voici un exemple plus concret pour Unix. Quelques documents, c-a-d. des fichiers *.text/txt simples, se trouvent dans un répertoire /home/schneide/schneide/methodo/R/ex. On va les importer dans un corpus "tm".

On vérifie le working directory et on charge la bibliothèque tm

getwd()
 [1] "/home/schneide"
library(tm)

On définit le chemin:

archive_test <- file.path ("schneide", "methodo", "R", "ex")

On affiche les fichiers du répertoire:

dir (dirr)
 [1] "how-to-get-a-phd.text"                               
 [2] "In-the-beginning-was-the-command-line-Stephenson.txt"
 [3] "logic-and-qual-res.text"  
 ...

On crée un corpus

library(tm)
corpus.source <- Corpus(DirSource(archive_test))

On examine le corpus

# short summary information
show (corpus.source)
print (corpus.source)
 <<VCorpus (documents: 6, metadata (corpus/indexed): 0/0)>>

On peut aussi examiner des détails

#Affiche tout (inutile, car trop)
inspect(corpus.source)
# Afficher un élément, 
inspect(corpus.source[1:3])

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.

chemin <- file.path ("...")
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readDOC))  
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readPDF))

Aspirer et nettoyer des pages web

Il existe plusieurs méthodes et libraries pour cela.

La librairie tm.plugin.webmining

On conseille d'installer le package tm.plugin.webmining car il combine l'aspiration avec des filtres HTML/XML.

• 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), taper R CMD javareconf. Enfin l'installation n'a pas pas marché sous Ubuntu....

Ensuite

install.packages("tm.plugin.webmining")

Alternativement, il existe des logiciels de web scraping (trois sont listés dans la vignette R Short Introduction to tm.plugin.webmining

Charger la bibliothèque

library("tm.plugin.webmining")

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 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

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 = ' ')

Aspirer une page MediaWiki

Les MediaWiki ont une API qui autorise l'extraction de contenus de pages, un bon exemple est ce wiki:

Afficher l'API:

http://edutechwiki.unige.ch/fmediawiki/api.php

Exemple: Contenu d'une page sous format XML (qu'il va aussi falloir nettoyer, mais moins)

http://edutechwiki.unige.ch/fmediawiki/api.php?action=parse&page=Civilization&format=xml

Transformations

Il existe un certain nombre de fonctions qui permet de "nettoyer" le texte

Partant avec un corpus, appelé corpus0, on peut effectuer plusieurs opérations, par exemple:

stripWhitespace()

Enlève les blancs en trop

corpus1 <- tm_map(corpus0, stripWhitespace)

tolower();

Met tous les mots en minuscules

corpus2 <- tm_map(corpus1, tolower)

removeWords(....),

Enlever des mots

Par exemple des stopwords en Anglais: corpus3 <- tm_map(corpus2, removeWords, stopwords("english"))

ou en français: corpus5 <- tm_map(corpus3, removeWords, stopwords("french"))

Par exemple une liste de mots: code>xxx = tm_map(corpus2, removeWords, c("Daniel", "Kaspar", "TECFA"))

removePunctuation()

Enlever les ponctuations

Remplacer des caractères (merci à Graham Williams)

for (j in seq (corpus0) {
  docs[[j]] <- gsub ("/", ," ", docs[[j]])
  docs[[j]] <- gsub ("@", ," ", docs[[j]])
 ......
}

Evidémment on peut aussi utiliser des expression régulières, par exemple une qui tue les balises XML/HTML

gsub("<.*/>","",string)

removeNumber()

Enlever des nombres

stemDocument()

Faire du stemming

  library(SnowballC)
  corpus9 = stemDocument(corpusx, language = meta(corpusx, "language"))

Méthodes d'analyse

.....

Topic Modeling

(à faire)

Exemple EduTechWiki

(en construction !!)

Cet exemple est directement inspiré par le billet Text mining in R – Automaticcategorization of Wikipedia articles de Norbert Ryciak.

Prérequis

Il faut avoir les librairies stringi, proxi et tm. Donc si nécessaire, il faut les installer. Par exemple, en ligne de commande:

install.packages("proxy")

Importer les documents

On peut directement importer des pages html (donc des pages wiki):

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))

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.

• Stefan Theussl, Ingo Feinerer & Kurt Hornik, Distributed Text Mining with tm, http://www.rinfinance.com/agenda/2010/Theussl+Feinerer+Hornik.pdf
  • Aussi par les auteurs, contient des exemples différents.

• Grahan Williams, 2004). Data Science with R Text Mining, http://onepager.togaware.com/TextMiningO.pdf
  • Alternative et complément au tutoriel officiel, un peu plus systématique. A mon avis le meilleur texte pour commencer - Daniel K. Schneider (discussion) 1 octobre 2014 à 20:34 (CEST)

• Jon Starkweather, Introduction to basic Text Mining in R, http://it.unt.edu/benchmarks/issues/2014/01/rss-matters
  • Assez utile pour débuter

• Topic Models Homework #1A: R Coding (part of a workshop documentation]. This shows how to use the lda package.

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.

• Text mining in R – Automatic categorization of Wikipedia articles par Norbert Ryciak, Juin 2014, article en ligne.
  • Bref billet qui montre l'essentiel de ce qu'il faut savoir pour commencer à analyser EduTechwiki
  • Ceci dit, le code ne semble plus marcher "tel quel" ....

• Mining twitter with R

• text mining of Twitter data with R