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

De EduTech Wiki
Aller à la navigation Aller à la recherche
Ligne 182 : Ligne 182 :
<source lang="javascript">
<source lang="javascript">
   library(SnowballC)
   library(SnowballC)
   corpus9 = <code>stemDocument(corpusx, language = meta(corpusx, "language"))</code>
   corpus9 = stemDocument(corpusx, language = meta(corpusx, "language"))
</source>
</source>


Version du 2 octobre 2014 à 10:45

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:

Introduction

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

Autre packages utiles

  • stringi (permet de manipuler des chaines de caractères)
  • proxy (analyses de proximités)

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

Les corpus

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 données et/ou en tapant des données.

Il existe 2 versions:

  • VCorpus (volatile, lorsqu'on arrête R, il faut la refaire ...
  • PCorpus (endroit unique où le corpus est stocké)

Pour construire un corpus, il faut donner deux arguments

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

Demander à R des informations concernant le type de sources et de readers: 

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

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

(1) Définissez le working directory 

# lister 
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 les fichiers. 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, avec une syntaxe "Unix" cela marchera aussi: D:/data/exemples/txt

Voici un exemple plus concret pour Unix ou j'ai mis un certain nombre de documents *.text/txt simples dans un répertoire ~/schneide/methodo/R/ex"·

On vérifie le working directory 

> getwd()
[1] "/home/schneide"

On définit le chemin: 

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

On regarde ce qui a dedans: 

> 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)
corpus0 <- Corpus(DirSource(dirr))

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

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). Peut-être il faut installer une version "plus lourde"

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 libarairie 

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

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

.....


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.

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.
Récupérée de « https://edutechwiki.unige.ch/fmediawiki/index.php?title=Text_mining_avec_R&oldid=38208 »