Cela fait un moment que je n’ai plus posté d’articles ici… Ce n’est absolument pas parce que je me suis désintéressée des sujets principaux de ce blog, à savoir : R et les statistiques, bien au contraire !
En fait, si je n’ai plus écrit ici depuis un bon moment, c’est parce que j’étais en train de travailler sur un nouveau projet : monter mon entreprise !

J’ai donc l’immense plaisir de vous annoncer la naissance de ma société spécialisée dans le conseil en statistiques et la formation R : la société DACTA.
Pourquoi DACTA ? Car le mantra / la philosophie derrière cette entreprise est la suivante : accompagner mes clients « From Data to Action » !

Je ne vais pas m’étendre ici en détails sur tous les tenants et les aboutissants de la création d’entreprise et ce qu’implique d’être à son compte (même si c’est passionnant et je serais ravie d’en parler avec vous pendant des heuuuures ;), mais toujours est-il que je suis vraiment contente d’avoir sauté le pas ! Pour le moment DACTA n’en est qu’à ses balbutiements, mais j’ai déjà quelques projets assez prometteurs en perspective et j’ai surtout rencontré des tas de personnes super intéressantes ces derniers mois, et quoi qu’il arrive, rien que pour l’expérience humaine cela vaut le coup :D

Bref, si vous souhaitez continuer à suivre mes aventures, c’est maintenant par ici que ça se trouve : bienvenue sur le blog de DACTA !

A très bientôt j’espère ! :)

 
- 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 célébrons aujourd’hui (20 octobre 2010) pour la première fois la Journée mondiale de la statistique, que l’Assemblée générale des Nations Unies a proclamée pour faire ressortir l’importance du rôle que joue la statistique dans nos sociétés.
Faisons de cette Journée mondiale de la statistique un succès, en reconnaissant et en célébrant le rôle des statistiques dans le développement économique et social de nos sociétés et en consacrant de nouveaux efforts et des ressources au renforcement des capacités statistiques nationales. »

— M. Ban Ki-moon, Secrétaire général de l’ONU
Journée mondiale de la statistique, 20 octobre 2010

L’édition 2015, quant à elle, aura pour thème : “De meilleures données. Une vie meilleure”. Rien que ça ;)

Sur le site officiel, on trouve la description suivante :

Selon UNStats (= United Nations Statistics Division), l’année 2015 est la pierre angulaire des statistiques officielles : avec la conclusion des Objectifs du Millénaire pour le Développement (Millennium Development Goals), l’agenda 2030 pour le Développement Durable, la révolution des données, les préparatifs pour le programme de recensement de la population mondiale et des logements prévu pour 2020, et bien plus encore.

Et ils ont même réalisé un petit spot vidéo tout mignon :

Pour suivre ce qui se passe durant la journée sur twitter : #StatsDay15
 

Ah et pour finir, sachez également que le 20 octobre c’est aussi ma fête ! Coïncidence… ;)

Et vive les stats !

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

Première étape, choisir le thème de mon blog !

Ça m’a pris un sacré paquet de temps de parcourir la gigantesque bibliothèque de thèmes disponibles pour WordPress, et j’ai fini par jeter mon dévolu sur un thème qui se rapprochait vraiment de l’idée que j’avais en tête pour le design de mon blog. Il ne me restait plus qu’à le personnaliser : allez hop, les mains dans le cambouis !
 
C’est là que tout se gâte et plus je creuse, plus je me rends compte que le thème que j’avais sélectionné n’est pas vraiment très bien construit et je galère pas mal pour faire les modifications que je souhaite (bon ok, c’est peut-être aussi un peu parce que le CSS et moi, bah disons qu’on n’est pas très copains ^^). Mais bref, je ne démords pas et je finis par avoir un rendu proche de ce que j’avais en tête. Mon 1er blog !
[EDIT] En fait, l’éclosion de ce blog a été pas mal retardée et entre temps j’ai totalement changé d’avis et de thème pour mon blog ! Du coup, connaissant un peu plus WordPress, j’ai recherché un thème un peu mieux « construit » que le précédent (en prenant des critères que je jugeais indispensables dans ma recherche de thème tels que par exemple « responsive ») et je suis tombée sur le thème actuel qui m’a donné beaucoup moins de fil à retordre que le précédent ! La seule petite spécificité a été le fait que j’ai dû traduire certains éléments de mon thème, mais j’ai trouvé une manière assez simple de faire cela sous WordPress, je reviendrais sûrement dessus dans un prochain article-tuto ;)

 
Viens ensuite une autre étape de personnalisation, une fois que le design est ok, il faut passer au contenu !
C’est là que j’ai découvert la caverne d’Ali Baba : les plugins WordPress ^^
Il en existe de toutes sortes et pour à peu près toutes les fonctionnalités dont vous pourriez rêver. Par contre, ces plugins sont créés par de gentils contributeurs mais ne sont donc pas forcément tous très optimaux (attention aux plugins trop lourds qui vont ralentir votre blog !) ou bien sécurisés.
 
Bref, après avoir passé (encore ^^) un bon paquet de temps à parcourir la bibliothèque de plugins WordPress et à les tester sur mon blog, j’ai fini par arrêter ma sélection.
Voici donc la liste (non exhaustive) de mes plugins WordPress préférés :

• QuickShare : plugin de partage d’articles sur les réseaux sociaux, bien fait, facilement paramétrable et surtout, personnalisable, via l’interface d’admin WP.
• Crayon Syntax Highlighter : plugin pour afficher du code sur son site, plutôt bien fait, notamment avec l’option permettant de récupérer directement le code, et permettant de personnaliser le rendu. Des tas de plugins pour afficher du code existent et j’en ai testé quelques-uns, ma préférence allant au final à celui-ci ^^
• WP Backup : plugin permettant de gérer les sauvegardes (« backup ») automatiques de son site WP directement via l’interface d’admin, sauvegardes faites sur son propre serveur ou via ftp sur son NAS par exemple, simple et efficace !
• Wordfence Security : peut-être la meilleure trouvaille en terme de plugins WP, ce plugin permettant de gérer la sécurité d’un site WP est vraiment très complet, de l’avertissement par mail à chaque connexion au blocage automatique des tentatives d’accès non autorisés, en passant par des rapports réguliers sur tout ce qui se passe sur le site, notamment les modifications des différents fichiers sources (attention, pour accéder à l’ensemble des fonctionnalités, il faut sortir le porte-monnaie mais il est à noter que la version gratuite est déjà plus que correcte).

Voilà pour le tour d’horizon de mes premières découvertes WordPress, je continue à en apprendre plus de jour en jour mais j’espère que le rendu et les fonctionnalités actuels du blog vous conviennent déjà bien :)
 

Et vous alors, quels sont vos astuces et plugins WordPress préférés ?
 

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

Vous trouverez ici des articles sur des sujets qui me passionnent : les statistiques, R (je suis faaaan !), les nouvelles technologies et autres geekeries diverses ^^

Bonne lecture à tous ! :)