Tutoriel tm text mining package
Tutoriels R | |
---|---|
▲ | |
◀▬ | |
⚐ brouillon | ☸ intermédiaire |
⚒ 2014/11/26 | ⚒⚒ 2014/11/18 |
Prérequis | |
Voir aussi | |
Sous-pages et productions: |
Introduction
tm est un paquet (extension) R. C'est un "framework" pour l'analyse statistique de textes. 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.
Ce tutoriel montrera comment profiter de la plupart des fonctionalités du paquet tm. On s'intéressera aussi à l'interopérabilité.
- le paquet tm
- Cran.r: tm: Text Mining Package
- Home page
- Rdocumentation: tm
- Vignette (texte d'introduction): ntroduction to the tm Package Text Mining in R
- Extensions à tm
- 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 aussi exemple IRaMuTeQ, un front-end graphique R gratuite qui permet de faire des analyses selon "l'école française")
Importer des fichiers avec le paquet tm
tm est le paquet "text mining" le plus populaire de R. Comme on va surtout travailler avec ce paquet, il va falloir l'installer si nécessaire.
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:
- 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:
library(tm)
Si nécessaire, installez ce paquet avec R-Studio ou tapez:
install.packages("tm")
Importation de documents et 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 textes.
Il existe 2 versions:
VCorpus
alias >code>Corpus. Ce type de corpus est volatile, lorsqu'on arrête R, il faut reconstruire le corpus ...PCorpus
(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).
Vcorpus
(objet_source, méthode_pour_lire)- L'exemple suivant lit une source en mode "simple" et en français:
VCorpus( DirSource(txt, encoding = "UTF-8"), readerControl = list(reader=readPlain, language="fr") )
- Exemple qui utilise un reader par défaut.
VCorpus( DirSource(txt, encoding = "UTF-8")
# on utilise les défauts
Voici quelques éléments à savoir lorsqu'on construit un corpus
- Identifier un type de 'source de données: soit
DataframeSource
,DirSource
,URISource
,vectorSource
ouXMLSource
- Definir le reader, c-a-d. on peut définir la manière dont le texte est lu avec
readerControl=
. On peut notamment définir le type de document à lire (readDOC
,readPDF
,readPlain
,readXML
,readTabular
), la languelanguage=...
.
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
# Utilise le sous-répertoire tm/texts/txt dans votre bibliothèque système et assigner cette source à la variable ''txt''
txt <- system.file("texts", "txt", package = "tm")
# Lire le texte de chaque fichier et mettre dans le corpus assigné à la variable ''ovid''
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]]
Structures de données
Il est toujours utile de comprendre et de vérifier les types et classes de données. Un Corpus a comme type "list" > typeof(ovid) [1] "list"
Le classe d'un objet Corpus est VCorpus (alias Corpus) et qui sont des classes de type "S3".
> class(ovid)
[1] "VCorpus" "Corpus"
La classe Corpus définit une structure et un certain nombre de méthodes.
La structure est composé de:
- une liste de jeux de documents []
- une liste de documents individuels [[]]
- des métadonnées:
meta</meta>
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: 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 /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 (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"
...
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 le premier document,
inspect(corpus.source[1])
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 (download)
- Dézippez et copiez soit les fichiers 32bit, soit les 64 bit dans un répertoire. Je conseille
c:\soft\xpdf
. 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 calibre dans ce répertoire ....
Résumé de la syntaxe:
chemin <- file.path ("...")
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readDOC))
corp <- Corpus (DirSource (chemin), readerControl=list (reader=readPDF))
Exemple:
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")
Aspirer des pages web
Il existe plusieurs méthodes et paquets 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 avec une combinaison des deux. Une fois qu'on a constitué un corpus, il faut "nettoyer" les textes, voir le chapitre suivant. Ceci dit, certains paquets permettent d'effectuer des filtrages pendant la lecture.
- La fonction Corpus peut directement lire des pages sur Internet. Le résultat sera "brut" et nécessitera un traitement
- Le paquet tm.plugin.webmining est spécialisé pour aspirer des informations qui viennent de sites spécialisés (comme Reuteurs, Yahoo, etc.)
- Le paquet XML permet d'extraire des contenus selon certaines méthodes DOM.
Création d'un corpus avec tm
Les fonctions "Corpus" du paquet tm permettent aussi de lire des URLs.
Principe:
- On définit une liste d'URLS et on la donne comme paramètre à la fonction Corpus. Autrement dit une liste d'URLs est une source comme un répertoire.
liste_URLs <- c("http://tecfa.unige.ch", "http://unige.ch/")
#On construit le corpus
Corpus.brut <- Corpus(URISource(list_URLs), readerControl = list(language="fr"))
Voici un exemple un peu plus élaboré qui montre comment créer un corpus avec des pages Mediawiki. Il nous semble qu'il est préférable d'utiliser la méthode expliquée plus loin et qui profite de l'API Mediawiki. L'utilisation d'URLs avec des "blancs" ne semble pas marcher sous Linux, OK sous Windows. Il faudrait substituer des caractères, c-a-d produire un semblant d'un URL correctement "urlencoded".
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))
Utilisation du paquet tm.plugin.webmining
Le paquet tm.plugin.webmining combine l'aspiration avec des filtres HTML/XML et des fonctions toutes prêtes pour analyses des contenus qui viennent de Reuters, Yahoo, etc. L'installation de ce paquet n'est pas forcément facile.
- Installation sous Windows
- Ce package nécessite Java, probablement une version pour développeurs. Ce plugin nécessite également les paquets R "XML" et "CURL" et qui seront installés automatiquement si tout va bien.
- Sous Win8, le package s'installe sans problème, mais ne trouve pas Java (Win8). Il faut soit savoir bricoler les chemins d'environnement soit (plus facile) installer Java JDK, donc le kit de développement. Ce dernier est disponible qq. part chez Oracle. Le plus facile et de chercher "Download Java JDK SE" et si vous tombez sur une page chez Oracle de type "Java SE Development Kit 8 Downloads" c'est bon ....
- Sous Linux
Dans une console Linux (sous root), pour indiquer l'emplacement de Java, taper:
sudo R CMD javareconf
.
Il faut également installer préalablement des bibliothèques de développement Curl et XML, sinon vous allez recevoir des messages d'erreurs comme ERROR: configuration failed for package ‘RCurl’
, rm: cannot remove 'a.out.dSYM': Is a directory
sudo apt-get install libcurl4-openssl-dev
sudo apt-get install libxml2-dev
Ensuite, on peut installer le paquet. Alternativement, utilisez la facilité "Install" de RStudio.
install.packages("tm.plugin.webmining")
- Alternatives pour le web scraping
Il existe d'autres logiciels de web scraping. Trois sont listés dans la vignette R Short Introduction to tm.plugin.webmining. Il faut envisager d'utiliser ces outils externes lorsque vous téléchargez des gros volumes. Dans ce cas, on enregistre les pages dans des répertoires sur votre disque dur et on les importe dans R comme source locale.
- Charger la bibliothèque
library("tm.plugin.webmining")
On peut assez facilement enregistrer une page web. La solution pour le débutant est un simple "save as". Mais on conseille d'abord d'afficher une version "print" si elle existe (élimine déjà un certain nombre d'informations inutiles).
- Filtrage de sections inutiles
La plupart des pages web contiennent de l'information inutile
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 et génère une structure R qui représente un arbre XML/HTML. Cette fonction connait des paramètres nombreux et fait des choses assez différentes selon la combinaison de paramètres. Notez que d'autres variantes comme la fonction xmlTreeParse
existent. Elle diffèrent par rapport aux paramètres par défaut.
Une fois qu'on a "digéré" un document XML ou HTML en R, on peut ensuite utiliser tout l'éventail des technologies XML, par exemple extraire des listes de paragraphes basés sur des noms de 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 = ' ')
Méthode "XML" via l'API pour Mediawiki
Les MediaWiki ont une API (Application programmer interface) 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 l'API de n'importe quel MediaWiki (à moins qu'il soit vérouillé):
La page affiché montre quel type d'informations on peut exporter et de quelle façon. Il existe aussi une documentation complète des query sur Mediawiki.org. Nous allons d'abord 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 d'une page récupéré via l'API. Si votre navigateur affiche le contenu, vous verrez que tout le contenu se trouve dans une balise "text".
Extraction d'une liste de pages
# ----------- Les bibliothèques
library(tm)
library(tm.plugin.webmining)
library(SnowballC)
library(XML)
# Path
# Linux
setwd ("~/schneide/methodo/R")
# Windows
# setwd("s:/methodo/R")
getwd()
# ----------- Mettre des pages wiki dans un corpus ------------
#Une longue procédure pour avoir une liste d'articles dans un string
# ATTENION aux noms des pages, utilisez des URL (URlEncoded)
# certains caractères ok pour le web ne passent pas en R, par exemple les "curly" apostrophes
url_start <- "http://edutechwiki.unige.ch/fmediawiki/api.php?action=parse&page="
url_end <- "&format=xml"
titles <- c("1066", "Activate", "Alice", "Argument_Wars", "CeeBot_4", "Chevron", "Cité_romaine", "Citéjob-négo", "Cyberbudget", "Darfur_is_dying", "E-psych", "Elude", "Energy_City", "Envers_et_contre_tout", "Eonautes", "FacteurAcademy", "Foodforce", "Get_the_glass", "Glucifer", "Halte_aux_catastrophes", "Happy_Night", "I-progress", "ICE-D", "InfinITy", "Ivy%E2%80%99s_Meadow", "J%27apprends_J%27entreprends", "K-ROBOT", "Mon_entretien_d%27embauche", "MySQLgame", "Oiligarchy", "Orbitrunner", "Petits_Détectives", "Phun", "Play_the_news", "Real_Lives", "RobotProg", "ScienceMuseum", "September_12th", "StarBankTheGame", "Super_Kimy", "SuperBetter", "TechnoCity", "The_Great_Flu", "The_Traveler_IQ_Challenge", "Timeout", "Tree_Frog", "Typershark", "Une_journée_au_fil_de_l%27eau")
# 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
# Cette fonction extrait juste l'élément XML "text" (voir l'API des mediawiki)
readMWXML <-
readXML (spec = list (content = list ("node", "//text"),
heading = list ("attribute", "//parse/@title")
),
doc=PlainTextDocument())
# Attention: Casse (notamment sous Ubuntu) si les URLs ne sont pas correctement encodés
wiki.source <- VCorpus(URISource(article_list, encoding="UTF-8"),
readerControl=list(reader=readMWXML, language="fr"))
# On change les "id" (titres à la place d'URLs illisibles)
for (j in seq.int (wiki.source)) {
meta(wiki.source[[j]],"id") <- titles[j]
}
# Ajouter une balise html autour du tout - c'est du bon vodoo
wiki.source <- tm_map (wiki.source, encloseHTML)
# Ecrire les fragments HTML dans des fichiers (inutile pour une analyse statistique, mais permet l'inspection)
writeCorpus(wiki.source, path="./wiki_txt_html")
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
<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>
.....
Extraction d'une catégorie
L'API d'un Médiawiki permet également de lister les membres d'une catégorie. La documentation API:Categorymembers explique comment.
Pour extraire une liste de noms, on peut utiliser l'URL suivant:
Explications:
action=query
indique qu'on transmet une requête
list=categorymembers
indique qu'on veut lister les membres d'une categorie
cmtitle=Category:Jeux_p%C3%A9dagogiques
important: Définit le nom de la catégorie (copié/collé depuis l'URL de la page, http://edutechwiki.unige.ch/fr/Cat%C3%A9gorie:Jeux_p%C3%A9dagogiques)
cmtype=page
indique qu'on en prend que les pages (et pas les sous-catégories)
format=xml
indique le format de sortie (voir API:Data formats)
Problèmes
- Error
- 1: Extra content at the end of the document
- Si vous avez le message Error: 1: Extra content at the end of the document, il est probable que R demande un faux URL au wiki. Celui-ce répond avec un message d'erreur.
- Solution: Utiliser des noms des URLs qui sont strictement URL-encoded (donc pour des pages wiki, il faut par exemple remplacer les " " par des "_".
Vous pouvez utiliser le debugger pour trouver un URL cassé (pas trouvé d'autre moyen):
- Dans R-Studio: Menu Debug; cocher "On Error -> Break in code"
- Dans le panneau Traceback, sélectionner la ligner readerControl$....
- Dans le panneau Values, ouvrir elem, puis regarder uri
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
<tm_map> 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é corpus0
, on peut effectuer plusieurs opérations de transformation, 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"))
- ou une liste explicite de mots:
xxx = tm_map(corpus2, removeWords, c("Daniel", "Kaspar", "TECFA"))
- removePunctuation()
- Enlever les ponctuations
- removeNumber()
- Enlever des nombres
- stemDocument()
- Faire du stemming
library(SnowballC)
corpus9 = stemDocument(corpusx, language = meta(corpusx, "language"))
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 à Graham Williams)
for (j in seq (corpus0)) {
corpus0[[j]] <- gsub ("/", " ", corpus0[[j]])
corpus0[[j]] <- gsub ("@", " ", corpus0[[j]])
......
}
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".
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 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)