- Shiny : qu’est-ce que c’est ? -

Shiny est un package R, développé par RStudio, qui permet la création de pages web interactives sur lesquelles il est possible de réaliser toutes les analyses / actions disponibles sous R.

Sa grande force est le fait qu’il n’y a absolument pas besoin de connaître ni HTML, ni CSS, ni Javascript : tout se fait directement en R ! Cela fait de ce package un outil très puissant et très prisé des fans de R ^^
 

- Shiny : à quoi ça ressemble ? -

Pour voir quelques exemples d’applications shiny, voici plusieurs liens :

• Galerie Shiny (avec des exemples de bases) : http://shiny.rstudio.com/gallery/
• « Shiny user showcase » (avec des exemples un peu plus complexes et sophistiqués) : https://www.rstudio.com/products/shiny/shiny-user-showcase/
• « Show me Shiny » (pas mal d’autres exemples intéressants) : http://www.showmeshiny.com/

- Shiny : comment ça marche ? -

Après avoir installé et chargé le package « shiny » dans R (pour l’installation de package R, voir par exemple ici), il faut créer son application shiny qui sera composée de deux fichiers : un fichier « ui.R » et un fichier « server.R » .

La partie « ui » : User Interface script, contrôle la mise en page et l’apparence de l’application.
La partie « server » : Server script, contient les instructions dont l’ordinateur a besoin pour construire l’application.

Exemple basique (issu du tutoriel officiel) :

> « ui.R » :

library(shiny)

# Define UI for application that draws a histogram
shinyUI(fluidPage(

  # Application title
  titlePanel("Hello World!"),

  # Sidebar with a slider input for the number of bins
  sidebarLayout(
    sidebarPanel(
      sliderInput("bins",
                  "Number of bins:",
                  min = 5,
                  max = 50,
                  value = 30)
    ),

    # Show a plot of the generated distribution
    mainPanel(
      plotOutput("distPlot")
    )
  )
))

> « server.R » :

library(shiny)

# Define server logic required to draw a histogram
shinyServer(function(input, output) {

  # Expression that generates a histogram. The expression is
  # wrapped in a call to renderPlot to indicate that:
  #
  #  1) It is "reactive" and therefore should
  #     re-execute automatically when inputs change
  #  2) Its output type is a plot

  output$distPlot <- renderPlot({
    x    <- faithful[, 2]  # Old Faithful Geyser data
    bins <- seq(min(x), max(x), length.out = input$bins + 1)

    # draw the histogram with the specified number of bins
    hist(x, breaks = bins, col = 'skyblue', border = 'white')
  })
})

Puis pour lancer l’application et la tester :

shinyApp(“C:/monchemin/mondossiercontenantlesfichiersR/”)

- Shiny : et ensuite ? -

Une fois qu’on est satisfait de son appli « shiny », il va falloir procéder à son déploiement, c’est-à-dire la mettre sur le net (pour l’instant tout avait été fait en local).

Pour cela plusieurs options : soit passer par la plateforme « shinyapps.io » mise à disposition par RStudio (très pratique si on veut faire des tests ou partager rapidement son appli), soit passer par l’installation d’un serveur shiny (tout à fait faisable sur une instance AWS par exemple).

Pour plus de détails sur ces étapes, voir les liens suivants : http://www.shinyapps.io/ et https://www.rstudio.com/products/shiny/shiny-server/.

> Exemple avec le lien vers l’appli de démo présentée plus haut, hébergée sur « shinyapps.io » : https://superstatisticienne.shinyapps.io/demo1/
 

- Shiny : pour aller plus loin -

Il existe également un autre package plus ou moins « dérivé » de celui-ci : le package « shinydashboard ». Il présente des fonctionnalités similaires mais un « design de base » de l’appli un peu différent, plus proche des « tableaux de bords » (d’où son nom ^^) très à la mode en ce moment.

Et pour les graphiques, de nombreux packages permettent la mise en place de graphiques dynamiques basés sur du Javascript, tels que par exemple : « ggvis » , « rCharts » , …

A la recherche d’aide pour la création de votre appli « shiny » avec R ?
Il y a plusieurs possibilités telles que par exemple :

• Pour commencer, le tutoriel « shiny » : http://shiny.rstudio.com/tutorial/
• Le support technique de RStudio (si besoin) : https://support.rstudio.com/hc/en-us
• Le Google Group « shiny-discuss » (pour des questions générales sur la création d’appli shiny) : https://groups.google.com/forum/#!forum/shiny-discuss
• Le Google Group « shinyapps-users » (pour des questions techniques plutôt liées au déploiement) : https://groups.google.com/forum/#!forum/shinyapps-users
• Et toujours, le forum « Développez.com » dédié à R : http://www.developpez.net/forums/f1179/autres-langages/autres-langages/r/

[NEWS du 12/01/2016] De nouvelles fonctionnalités très intéressantes ajoutées dans la dernière version de « shiny » (version 0.13.0), telles que par exemple des templates HTML, la possibilité de créer des événements Javascript et aussi des « gadgets shiny » (voir ici) ^^

Sinon, de mon côté, j’ai déjà réalisé quelques applis shiny de tests et je travaille encore sur d’autres actuellement, je vous en reparle un de ces jours ;-)

–> Et vous, avez-vous déjà testé le package R « shiny » ? Avez-vous des exemples d’appli à nous faire partager ?

Exemple :

Avec R, il est assez facile de réaliser des wordcloud plutôt chouettes (je vous l’ai déjà dit, R c’est bien ;) ), je vais donc vous montrer comment, avec un petit exemple en relation avec l’actualité.

- Charger les données -

Texte <- readLines("HommageNationalHollande-27112015.txt", encoding = "utf-8")

> Il s’agit du texte complet de l’hommage aux victimes des attentats du 13 novembre 2015, fait par le président François Hollande le 27 novembre (disponible sur internet).

 
- Charger les packages -

library(tm)  # ce package propose un ensemble de fonctions facilitant le traitement de donnees textuelles
library(wordcloud)  # ce package permet la creation de wordcloud

 
- Travail sur les données -

text_corpus <- Corpus(VectorSource(Texte))
text_corpus <- tm_map(text_corpus, content_transformer(tolower))
text_corpus <- tm_map(text_corpus, removePunctuation)
text_corpus <- tm_map(text_corpus, function(x)removeWords(x,stopwords(kind = "fr")))

> Explications :

– La 1ère instruction permet de transformer le texte « brut » en un élément de classe « corpus » (classe du package « tm »), sur lequel un ensemble de fonctions de traitement de texte pourront être directement appliquées.
– La 2nde instruction permet de transformer toutes les lettres majuscules en lettres minuscules (afin par exemple que « Hommes » et « hommes » soient traités pareil).
– La 3ème instruction permet de supprimer automatiquement tous les caractères de ponctuations.
– La dernière instruction permet de supprimer automatiquement une grande partie des mots « de base » d’une langue donnée (ici le français avec l’instruction : kind = « fr », par défaut il s’agit de l’anglais), tels que par exemple : le, la, les, de, des, à, où, …

 
- Wordcloud -

set.seed(123456)  # permet de "fixer un graine" pour l'alea, afin de pouvoir regenerer plusieurs fois le meme wordcloud

wordcloud(text_corpus, max.words = 200, colors = brewer.pal(8, "Dark2"),  rot.per=0)

Remarque : On voit ici qu’il reste encore certains mots qui ne sont pas particulièrement utiles pour ce wordcloud visant à mettre en valeurs les « grands thèmes » de ce discours d’hommage. On va donc tenter d’en supprimer quelques-uns pour voir si on obtient quelque chose de mieux.

 
- Wordcloud : version 2 -

text_corpus2 <- tm_map(text_corpus, function(x)removeWords(x,c("quils", "cestadire", "tout", "dun", "cest", "etaient", "etre", "parce", "ete", "sais")))  # n'importe quelle liste de mots peut egalement etre passee en argument de la fonction "removeWords"

set.seed(123456)
wordcloud(text_corpus2, max.words = 200, colors = brewer.pal(8, "Dark2"),  rot.per=0)

> Ce wordcloud pourrait encore être retravaillé mais il est assez intéressant, notamment si on se concentre sur les mots apparaissant en bleu : hommes, femmes, tous, comme, meme, nation, retranscrivant bien le message général d’unité et d’égalité de ce discours.

 
- Enregistrer son wordcloud dans un fichier externe -

png("monwordcloud.png")
wordcloud(text_corpus2, max.words = 200, colors = brewer.pal(8, "Dark2"),  rot.per=0)
dev.off()

> Fonctionne aussi en remplaçant « png » par « jpeg », « pdf », …

 
- Pour aller plus loin : personnalisation du wordcloud -

La fonction « wordcloud » du package éponyme possède un certain nombre de paramètres permettant de personnaliser ses wordcloud :

• Tailles maxi et mini des mots affichés :
  

  scale = c(4,0.5)

• Fréquence à partir de laquelle un mot sera retenu :
  

  min.freq = 3

• Nombre maximum de mots à afficher :
  

  max.words = Inf

• Affichage des mots dans un ordre aléatoire :
  

  random.order = TRUE

• Choix de couleur de mot aléatoire :
  

  random.color = FALSE

• Proportion de mots tournés à 90 degrés :
  

  rot.per = 0.1

• Couleur des mots (du moins au plus fréquent) :
  

  colors = "black"

• Autres paramètres pour le style des mots : type de police, taille des caractères, …

Exemple :

set.seed(123456)
wordcloud(text_corpus, max.words = 200, scale = c(5,0.2), colors = brewer.pal(8, "Paired"), vfont = c("gothic english","plain"), rot.per = 0.3)

Remarque : Pour le choix des couleurs, il est possible d’obtenir facilement des dégradés (ou palettes) « tout prêts » grâce au package « RColorBrewer » (installé avec le package « wordcloud ») et à la fonction « brewer.pal » utilisée ici dans les exemples.
Ci-dessous les différentes palettes de couleurs disponibles :

Et vous, avez-vous des exemples de wordcloud particulièrement réussis à partager ?

Nous allons donc voir comment faire cela avec R.
 

+ Chargement des données :

M <- read.csv("data_typo.csv", header = TRUE, sep = ";")

> Type du fichier d’exemple : CSV, séparateur « point-virgule », questions de type qualitatif et questions à choix multiples au format dichotomique (1 = « Cité » / 0 = « Non Cité »)
 
+ Visualiser le nom des variables/en-têtes de colonnes :

colnames(M)

 
+ Gestion des valeurs manquantes NA :

vm <- which(is.na(M$q1))  # sélectionner les individus ayant une valeur manquante à la question "q1" par exemple
vm <- which(is.na(M[, 3]))  # autre écriture si, par exemple, la question "q1" est en colonne 3 dans les données

# vm contient la liste des numéros de lignes correspondant aux individus ayant une valeur manquante (NA) pour "q1"

M <- M[-vm, ]  # exclusion des NA de q1 dans le jeu de données global

 
+ Sélection d’individus d’après un filtre :

ut <- which(M$util == 1)  # ex : on ne veut réaliser l'analyse que sur les profils "utilisateurs", i.e. les gens ayant choisi la modalité 1 à la question "util"

# ou
ut <- which(M[, 1] == 1)  # si la question "util" est en 1ère colonne dans les données

# ut contient la liste des numéros de lignes correspondant aux individus "utilisateurs"

M <- M[ut, ]  # selection des profils "utilisateurs" parmis le jeu de données global

 
+ Sélection des variables typo :

Un certain nombre de variables ont été retenues pour réaliser la typologie. On va donc récupérer les données correspondant à ces variables en particulier.

list_vars <- c(3:5, 12, 24:27)  # contient les numéros des colonnes correspondant aux variables choisies pour la typo

> Au final, « list_vars » contient les numéros suivants : 3, 4, 5, 12, 24, 25, 26 et 27

X <- M[, list_vars]

> La matrice « X » va contenir uniquement les variables (actives et illustratives) qui serviront dans la typologie (dans notre exemple : 8 variables).
 
+ Vecteur de poids :

Dans le cas où il existe une pondération sur les individus, on va avoir besoin d’un vecteur contenant ces poids.

poids <- M$poids

- Analyse des Correspondances Multiples -
 
+ Type des variables = « factor » :

Dans R, il va falloir spécifier que les variables utilisées pour notre analyse sont de type « qualitatif » (ie. avec un nombre fini de modalités entières) : il s’agit de mettre les variables de « X » au format « factor ».

X <- apply(X, 2, as.factor)

str(X)  # l'appel à la fonction "str" va nous permettre de vérifier que toutes les variables ont bien le type "factor" souhaité

 
+ ACM :

library(FactoMineR)  # va permettre de charger la librairie contenant la fonction permettant de réaliser l'ACM

acm <- MCA(X, ncp = 80, graph = FALSE, quali.sup = c(7, 8), row.w = poids)  # réalisation de l'ACM

Syntaxe : Arguments de la fonction « MCA »

 
+ Sélection des composantes :

On va sélectionner un nombre de composantes permettant d’obtenir le maximum d’informations (par exemple 80%).

vp <- acm$eig$eigenvalue  # vecteur des valeurs propres associées aux composantes de l'ACM

100*(cumsum(vp)/sum(vp))  # pourcentage cumulé d'info apportée par les composantes de l'ACM

> On va ensuite sauvegarder les composantes retenues (ainsi que les données initiales) dans un fichier csv :

IC <- acm$ind$coord[, 1:25]  # ici on a retenu 25 composantes

colnames(IC) <- paste0("Dim.", 1:25)

C <- cbind(M, IC)

write.csv(C, file = "data_total_with_acm_coord.csv", row.names = FALSE, quote = FALSE)

- Classification -
 
On va maintenant réaliser une classification sur les composantes de l’ACM que nous avons retenues afin de séparer nos individus en plusieurs groupes.

+ Dendrogramme :

dendro <- hclust(dist(model.matrix(~-1+Dim.1+Dim.2+Dim.3+Dim.4+Dim.5+Dim.6+Dim.7+Dim.8+Dim.9+Dim.10+Dim.11+Dim.12+Dim.13+Dim.14+Dim.15+Dim.16+Dim.17+Dim.18+Dim.19+Dim.20+Dim.21+Dim.22+Dim.23+Dim.24+Dim.25,C)), method = "ward")

plot(dendro)  # représentation de l'arbre de classification

# ou : représentation plus personnalisée de l'arbre de classification (nécessite une connexion internet)

source("http://addictedtor.free.fr/packages/A2R/lastVersion/R/A2R")

pdf("dendro5.pdf")  # va permettre de sauvegarder le dendrogramme au format pdf

A2Rplot(dendro, k = 5, lty.up = 1, lty.down = 1, boxes = FALSE, col.down = c("orange", "blue", "green", "red", "yellow"), lwd.down = 1, col.up = "black", show.labels = FALSE, main = "Dendrogramme")  # ici répartition en 5 groupes

dev.off()

> L’observation de l’arbre va nous permettre de décider d’un nombre k de groupes dans lesquels seront répartis les individus de l’étude.

Exemple de dendrogramme :

+ Répartition des individus dans les groupes et effectifs :

group5 <- cutree(dendro, k = 5)  # vecteur contenant le numéro du groupe (ici entre 1 et 5) auquel appartient chaque individu

table(group5)  # va renvoyer le tableau d'effectifs de chacun des 5 groupes

> On va ensuite sauvegarder les numéros de groupe des individus (ainsi que les résultats de l’ACM et les données initiales) dans un fichier csv :

T <- cbind(C, group5)

write.csv(T, file = "data_complete_with_groups.csv", row.names = FALSE, quote = FALSE)

- Description des groupes -
 
Maintenant que nous avons une répartition de nos individus en k groupes, ce qui va nous intéresser c’est de déterminer quels sont les éléments (variables) qui caractérisent ces différents groupes.
Pour cela, on peut utiliser la fonction : « catdes.w« , donc vous trouverez le code ci-dessous :
(il s’agit en fait d’une version très légèrement modifiée de la fonction « catdes » du package « FactoMineR », afin de pouvoir prendre en compte un poids sur les individus)

catdes.w<-function (donnee, num.var, proba = 0.05 , weight=NULL) 
{
   lab.sauv <- lab <- colnames(donnee)
   quali = NULL

   for (i in 1:length(lab))
   {
      lab[i] = gsub(" ", ".", lab[i])

      if (is.factor(donnee[, i]))
      {
         if (levels(donnee[, i])[1] == "")
         {	
            levels(donnee[, i])[1] = "NA"
         }

         if (i != num.var)
         {
            quali = c(quali, i)
         }
      }
   }

   quanti = (1:ncol(donnee))[-c(quali, num.var)]

   if (length(quanti) == 0)
   {
      quanti = NULL
   }

   colnames(donnee) = lab
   res = list()
   nb.modalite <- length(levels(donnee[, num.var]))
   nb.quali = length(quali)
   old.warn = options("warn")

   if(length(weight)==0)
   {
      weight<-rep(1,dim(donnee)[1])
   }

   if (nb.quali > 0) 
   {
      options(warn = -1)

      marge.li = xtabs(weight~donnee[, num.var])
      nom = tri = structure(vector(mode = "list", length = nb.modalite), names = levels(donnee[, num.var]))

      for (i in 1:nb.quali) 
      {
         Table <- xtabs(weight~donnee[, num.var] + donnee[, quali[i]])
         marge.col = xtabs(weight~donnee[, quali[i]])

         ML<-rowSums(Table)

         for (j in 1:nlevels(donnee[, num.var]))
         {
            for (k in 1:nlevels(donnee[, quali[i]]))
            {
               aux2 = Table[j, k]/ML[j]

               if(ML[j]==0)
               {
                  aux2 = 0
               }

               aux3 = marge.col[k]/sum(marge.col)

               if (aux2 > aux3) 
               {
                  aux4 = phyper(Table[j, k] - 1, ML[j], sum(ML) - ML[j], marge.col[k], lower.tail = FALSE) * 2
               }
               else 
               {
                  aux4 = phyper(Table[j, k], ML[j], sum(ML) - ML[j], marge.col[k]) * 2
               }

               if (aux4 < proba)
               {
                  aux5 = (1 - 2 * as.integer(aux2 > aux3)) * qnorm(aux4/2)
                  aux1 = Table[j, k]/marge.col[k]

                  tri[[j]] = rbind(tri[[j]], c(aux1 * 100, aux2 * 100, aux3 * 100, aux4, aux5))
                  nom[[j]] = rbind(nom[[j]], c(levels(donnee[,quali[i]])[k], colnames(donnee)[quali[i]]))
               }
            }
         }
      }

      for (j in 1:nb.modalite)
      {
         if (!is.null(tri[[j]]))
         {
            oo = rev(order(tri[[j]][, 5]))
            tri[[j]] = tri[[j]][oo, ]
            nom[[j]] = nom[[j]][oo, ]

            if (nrow(matrix(tri[[j]], ncol = 5)) > 1)
            {
               rownames(tri[[j]]) = paste(nom[[j]][, 2], nom[[j]][,1], sep = "=")
            }
            else
            {
               tri[[j]] = matrix(tri[[j]], ncol = 5)
               rownames(tri[[j]]) = paste(nom[[j]][2], nom[[j]][1], sep = "=")
            }

            colnames(tri[[j]]) = c("Cla/Mod", "Mod/Cla", "Global", "p.value", "v.test")
         }

      }

      res$category = tri
   }

   if (!is.null(quanti))
   {
      nom = result = structure(vector(mode = "list", length = nb.modalite), names = levels(donnee[, num.var]))

      for (i in 1:length(quanti))
      {
         moy.mod = by(donnee[, quanti[i]]*weight, donnee[, num.var], mean, na.rm = TRUE)
         n.mod = summary(donnee[, num.var])

         sd.mod = by(donnee[, quanti[i]]*weight, donnee[, num.var], sd, na.rm = TRUE)
         sd.mod = sd.mod * sqrt((n.mod - rep(1, nb.modalite))/n.mod)

         moy = mean(donnee[, quanti[i]]*weight, na.rm = TRUE)
         et = sd(donnee[, quanti[i]]*weight, na.rm = TRUE) * sqrt(1 - 1/sum(n.mod))

         for (j in 1:nb.modalite)
         {
            v.test = (moy.mod[j] - moy)/et * sqrt(n.mod[j])/sqrt((sum(n.mod) - n.mod[j])/(sum(n.mod) - 1))
            p.value = pnorm(abs(v.test), lower.tail = FALSE) * 2

            if (!is.na(v.test))
            {
               if (abs(v.test) > -qnorm(proba/2))
               {
                  result[[j]] = rbind(result[[j]], c(v.test, moy.mod[j], moy, sd.mod[j], et, p.value))
                  nom[[j]] = c(nom[[j]], colnames(donnee)[quanti[i]])
               }
            }
         }
      }

      for (j in 1:nb.modalite)
      {
         if (!is.null(result[[j]]))
         {
            oo = rev(order(result[[j]][, 1]))
            result[[j]] = result[[j]][oo, ]
            nom[[j]] = nom[[j]][oo]

            if (nrow(matrix(result[[j]], ncol = 6)) > 1)
            {
               rownames(result[[j]]) = nom[[j]]
               colnames(result[[j]]) = c("v.test", "Mean in category", "Overall mean", "sd in category", "Overall sd", "p.value")
            }
            else
            {
               result[[j]] = matrix(result[[j]], ncol = 6)
               rownames(result[[j]]) = nom[[j]]
               colnames(result[[j]]) = c("v.test", "Mean in category", "Overall mean", "sd in category", "Overall sd", "p.value")
            }
         }
      }

      res$quanti = result
   }

   options(old.warn)
   class(res) <- c("catdes", "list ")
   return(res)
}

 
Utilisation :

M <- read.csv("data_complete_with_groups.csv", header = TRUE, sep = ",")

vars <- c(3:5, 12, 24:27, 45)  # liste des numéros de colonnes correspondant aux variables utilisées pour la typo ET à la variable "groupe"

X <- M[, vars]

D <- apply(X, 2, as.factor)

donnees <- as.data.frame(D)

num.var <- 9  # la variable "groupe" est située en 9ème colonne de "donnees"

proba = 0.05  # seuil de significativité = 5%

weight <- M[, 2]  # le poids des individus est en 2ème colonne de M


source("catdes_w.R")  # va permettre d'indiquer à R où trouver le code de la fonction "catdes.w" qu'on aura au préalable sauvegardée dans une fichier nommé "catdes_w.R"

results <- catdes.w(donnees, num.var, proba = 0.05 , weight) 

G1 <- results$category$"1"
G2 <- results$category$"2"
G3 <- results$category$"3"
G4 <- results$category$"4"
G5 <- results$category$"5"

K <- rbind(rep("",5), round(G1,3), rep("",5), rep("",5), round(G2,3), rep("",5), rep("",5), round(G3,3), rep("",5), rep("",5), round(G4,3), rep("",5), rep("",5), round(G5,3), rep("",5))

write.csv(K, file = "Typo1_5groups_weighted.csv", quote = FALSE)  # va sauvegarder la description des groupes typo dans un fichier csv (qu'on pourra mettre en page par la suite, notamment en remplaçant les valeurs de type "q1_1=1" par le libellé correspondant)

- Lecture des résultats -
 
Exemple de description d’un groupe :

 
> Cla / Mod = 71,43 : 71,43 % des individus (parmis l’ensemble de la population à qui est posée cette question) qui sont « Non Satisfaits » par « la clarté de la présentation des informations » se retrouvent dans ce groupe.

> Mod / Cla = 78,43 et Global = 13,93 : dans ce groupe il y a 78,43 % des individus qui sont « Non Satisfaits » par « la clarté de la présentation des informations » alors que dans la population global il n’y en a que 13,93 %, il y a donc une sur-représentation de cette modalité dans le groupe.

> p.value = 3.70 10^-20 : La sur-représentation dans ce groupe de la modalité « Non Satisfaits » pour « la clarté de la présentation des informations » est significative au seuil 3.70×10^-20.

> v.test = 11.72 : valeur de la statistique de test permettant de déterminer la significativité des variables de description du groupe (si la valeur est positive, on aura une sur-représentation de la modalité considérée, si elle est négative, une sous-représentation).

C’est cette description de chacun des différents groupes qui va permettre ensuite de classer nos répondants dans des catégories bien spécifiques auxquelles on pourra donner des noms en rapport avec la description obtenue (par exemple « Les insatisfaits »).

En effet, une des grandes forces de R est sa licence GNU GPL et sa multitude de contributeurs.
Contributeurs qui peuvent donc, grâce au système de packages, partager leurs créations et fonctions R dans des domaines plus que variés.
Vous pouvez retouver la liste complète de ces packages ici : « CRAN Packages By Name », ou bien classés par thème ici : « CRAN Task Views ».

Je vous parlerai dans un prochain article de mes packages R préférés mais pour le moment, voyons comment les utiliser ^^

 
- Gestion des packages -

+ Installer un package dans R :

install.packages("nom_du_package", dependencies = TRUE)

> Il vous est ensuite demandé de sélectionner un « serveur miroir » pour récupérer le package.
 
+ Charger le package dans R :

library(nom_du_package)

> Et c’est parti ! ;)

 
Remarque : Si vous êtes sous Windows, il est aussi possible d’installer un package sous R en mode « clic-bouton » dans le menu « Packages > Installer un package » de R ou bien sous « R Studio » via le menu « Outils > Installer un package ».
 
Remarque 2 : Si vous êtes sous Linux, l’installation d’un package R nécessite d’être en root.

 
- Astuce pratique -

Si vous utilisez très souvent certains packages, il peut s’avérer fastidieux de devoir les charger à chaque nouvelle session de R. Une astuce consiste donc à paramétrer R de sorte à ce que ces packages soient chargés automatiquement à chaque lancement de R.
Pour cela, on va aller modifier le fichier .Rprofile (si ce fichier n’existe pas, il vous suffit de le créer à la racine de votre dossier de travail). Ici on va simplement y ajouter les lignes de code souhaitées, par exemple :

library(nom_du_package1)
library(nom_du_package2)

Il y a bien sûr tout un tas d’autres éléments / paramètres possibles qui peuvent être ajoutés dans le fichier .Rprofile, en fonction de vos besoins propres. Par exemple, vous pouvez utiliser le fichier .Rprofile pour spécifier un « serveur miroir » à utiliser par défaut :

options("repos" = c(CRAN = "http://cran.uk.r-project.org/"))

Par contre ATTENTION : si vous partagez votre code, prenez bien garde à spécifier les éléments nécessaires (tels que les packages par exemple) car les autres ne disposeront peut-être pas du même fichier .Rprofile que vous !

 
- Et aussi… -

Enfin, en dehors des packages « approuvés » disponibles sur le CRAN, il est également possible de charger dans R des packages que d’autres utilisateurs ont mis à disposition, par exemple sur leurs github personnels.
Pour cela, il faudra utiliser le package « devtools » et installer certains composants si vous ne les avez pas déjà (Rtools sous Windows par exemple). Vous pouvez trouver plus d’infos à ce sujet ici : https://github.com/hadley/devtools.
Personnellement je n’ai pas encore eu l’occasion de tester mais je trouve que c’est une très bonne idée :)

Bonne lecture !

– – – – – –

R est un langage de programmation et un environnement statistique, petit frère libre (licence GNU GPL) du langage S. R permet de faire de la manipulation de données, des analyses statistiques diverses et variées, des restitutions graphiques hautement personnalisables et bien plus encore, tout ça sur Windows, Unix ou Mac OS !

Le site officiel : http://cran.r-project.org/

Le principe et la force de R reposent sur ses nombreux contributeurs, auteurs de “packages” permettant toujours de nouvelles fonctionnalités et applications dans des domaines très variés (écologie, finance, médecine, psychologie, …).
Ces packages sont “validés” avant d’être publiés ici : http://cran.r-project.org/web/packages/ . Egalement, de nombreux packages « non encore officialisés » sont disponibles sur les dépo github d’utilisateurs passionnés et sont facilement intégrables dans R grâce au package « devtools ».
Je reviendrai plus en détails sur les packages R dans un prochain billet (lien à venir ici).

La version de R la plus récente est là 3.2.2 (« Fire Safety« ).

Egalement à voir, un IDE (multi-plateformes) vraiment bien fait pour R : RStudio.
Personnellement je ne suis pas habituée à travailler avec un IDE, mais plus je pratique sous RStudio, plus je découvre de fonctionnalités, plus je le trouve indispensable ! Je le recommande donc vivement ;)

Parmi les nombreux avantages de R : la multitude des formats de données pris en charge (texte, CSV, Excel, SAV, SAS, base de données SQL, …) et la possibilité de s’interfacer ou de faire appel à du code provenant d’autres langages/logiciels (Fortran, C, Python, Perl, SAS, Excel, …). Egalement la possibilité de générer des “rapports automatisés” en Word ou LaTeX ou encore de créer des applications (ou « tableaux de bord ») web dynamiques.

Besoin d’aide avec R ?

Il existe plusieurs mailing list : R-Help (anglais), SeminR et adelist (français) ainsi que des forums, dont le plus célèbre au niveau francophone : Forum R Developpez.com (j’en suis une des modératrices d’ailleurs ;) ).
Pour rechercher une fonction en particulier, je recommande : RSiteSearch.

Quelques tutoriels (liste non exhaustive) :

http://r.developpez.com/
http://pbil.univ-lyon1.fr/R/
http://cran.r-project.org/manuals.html

Egalement une super mine d’or sur le sujet : RBloggers !

Et bien sûr tout un tas de livres (dont pas mal publiés en français ces dernières années), dont certains dont je vous parlerais très certainement au fil des prochains articles ;)

[Mon expérience] En ce qui me concerne, j’ai découvert R en première année de master de maths appliquées et n’ayant pas trop d’expérience en programmation informatique, j’avoue qu’il m’a fallut un peu de temps pour m’y mettre ^^ Mais depuis, je ne peux plus m’en passer !
J’utilise R dans le cadre de mon travail pour tout un tas d’applications variées allant de “simples” analyses statistiques (analyses discriminantes, typologies, …) à la programmation de solutions ad hoc, et également pour mes petites “expériences” perso, notamment basées sur les merveilleuses idées des contributeurs sur “RBloggers” !
Je participe aussi activement à la communauté R en étant modératrice du forum dédié à R sur le site Developpez.com, n’hésitez pas à venir y faire un tour ;)
Egalement, depuis quelques temps je me suis mise à la création de dashboard R avec le package « shinydahsboard » et je dois avouer que plus j’avance dans mon apprentissage de ce package et plus j’aime ça (je vous en parle prochainement) ^^

Et vous, vous l’aimez comment votre R ?! ^^
 

Bon R à tous ! ;)