« Analyses statistiques avec R » : différence entre les versions

De EduTech Wiki
Aller à la navigation Aller à la recherche
mAucun résumé des modifications
 
(194 versions intermédiaires par 8 utilisateurs non affichées)
Ligne 1 : Ligne 1 :
=Introduction=
{{tutoriel
|fait_partie_du_cours=Tutoriels R
|fait_partie_du_module=Tutoriels R
|pas_afficher_sous-page=Non
|page_precedente=Les données R
|statut=à finaliser
|voir_aussi=Introduction à la modélisation des données avec R
|all_pages_module=Non
|cat tutoriels=Tutoriels R
}}
== Introduction ==


R est un langage de programmation et un environnement open-source permettant le traitement des données et les analyses statistiques. Sur cette page nous proposons un tutoriel permettant de s’initier à cet environnement. Dans un premier moment, nous présenterons les bases du fonctionnement de R. Par la suite, nous introduirons le traitement des données alphanumériques (analyse qualitative). Dans un troisième moment nous introduirons le traitement des données numériques (analyse quantitative). Enfin, nous présenterons les structures de contrôle.
Cet article fournit un tutoriel conçis sur le traitement des données numériques avec [[R]]. Une explication plus conceptuelle sur le fonctionnement de [[R]] pour les analyses est disponible dans la page [[Introduction à la modélisation des données avec R]].


== Pourquoi préférer R à d'autres logiciels de traitement de données ? ==
* Il s’agit d’un logiciel gratuit à code source ouvert
* Il est compatible avec les systèmes Windows, MAC OS et Linux
* Il s’agit d’un logiciel très puissant et complet
* Il est en essor permanent
* En cas de problème, des milliers d'utilisateurs sont prêts à vous aider !
= Fondements de R =
== Installation de R ==
Pour installer R dirigez-vous sur http://cran.r-project.org/ et télécharger l’environnement convenant au système d’exploitation de votre ordinateur.
== Introduction à l'environnement R ==
Voici comment l’environnement R se présente une fois l’application ouverte :
[[Fichier:R.png]]
L’interface de l’environnement R se présente par une fenêtre contenant une barre de menus, une barre d’outils et la console R. Cette dernière permet d’introduire des commandes R (ou expressions).
L’interprétateur de R traduit et exécute les commandes introduites par l’utilisateur.
Le prompt de R est représenté par le symbole > . Ce caractère signifie que l’interprétateur de R attend l’introduction d’une commande de la part de l’utilisateur.
Remarquons que l’interface standard graphique de R paraît élémentaire et peu ergonomique. Plusieurs interfaces graphiques existent et peuvent être installées. Nous recommandons l’installation de R-Commander et R-Studio.
== L'aide de R ==
La fonction help.start() permet d’acceder à l’aide en ligne de R.
La fonction help() ou ? permet d'obtenir de l’aide sur des commandes R spécifiques. Exemples :
help.start()
help(help) # lance la documentation de la fonction « help »
?(mean) # lance la documentation de la fonction « mean »
== Commentaires ==
Le symbole # permet d'ajouter des commentaires dans R. Tout ce qui est écrit après ce symbole n'est pas interprété par R. Prenons l’exemple suivant :
3 + 2 # Ceci est un commentaire... remarquez que R interprète ce qui vient avant le symbole # et nous donne le résultat de l'addition
Les commentaires sont très utiles en programmation pour décrire ce que le code fait.
== Les objets de R ==
Les  objets sont des entités stockés dans la mémoire de R. Il est important créer des objets afin de pouvoir les manipuler dans un deuxième moment. Les opérateurs d’assignation <- et -> permettent de créer et de stocker des objets dans la session de R courante. Exemples :
Poids <- 80 # L’objet Poids reçoit la valeur 80
80 -> Poids # L’objet Poids reçoit la valeur 80
Dans R, différents types d'objets peuvent être crées et traités. Voici les principaux objets :
a <- NULL # a est un objet nul, vide
b <- TRUE # b est un objet logique, booléen
c <- 101 # c est un objet numérique
d <- "Bonjour à tout le monde!" # d est un objet alphanumérique (il contient une chaîne des caractères)
Pour connaître le mode (type) d'un objet, utilisez la commande mode() :
mode(Poids)
mode(a)
mode(b)
mode(c)
mode(d)
Pour afficher la valeur d'un objet, on peut utiliser la fonction print(). Altérnativement on peut introduire tout simplement le nom de l’objet à afficher :
print(Poids)
Poids
Print(a)
a
Pour lister les objets existant dans la session de R, utilisez la fonction ls() ou objects() :
ls()
objects()
Enfin, on peut supprimer des objets avec la fonction rm() :
rm(Poids) # L'objet Poids est supprimé
rm(a) # L’objet a est supprimé
rm(b, c, d) # Les objets b, c et d sont supprimés
Dans les prochaines sections, nous présenterons les objets fondamentaux de R : les vecteurs, les matrices et les data-frames.
=== Les vecteurs ===
Un vecteur est un objet atomique : tous ses éléments sont caractérisés par le même mode (ou type). Plusieurs méthodes peuvent être utilisées pour générer un '''vecteur numérique'''. Le plus important est le collecteur c() :
c(3, 4, 1, 3) # vecteur numérique de longueur 4
Altérnativement, vous pouvez utiliser l'opérateur : , la fonction seq et la fonction rep :
1:15
seq(1,5, by = 0.2)
seq(1,5, length=10)
rep(1,10)
rep(1:3, times = 3)
rep(1:3, each = 3)
rep(1:3, times = 3, each = 2)
Pour générer un '''vecteur alphanumérique''', utilisez le collecteur c() associé à des guillemets :
c('H', 'F', 'F', 'H', 'F')
Alternativement, vous pouvez utiliser la fonction rep :
rep('H', 20)
Pour générer un '''vecteur logique''', utilisez les opérateurs >, >=, <, <=, ==, != :
10 == (2+1) # Donne FALSE car 10 est différent de 3
10 != 3 # Donne TRUE car 10 est différent de 3
10 >= 7 # Donne TRUE car 10 est supérieur égal à 7
1:10 == 6 # Donne un vecteur logique de longueur 10. La valeur TRUE apparaît quand la condition est satisfaite ; la valeur FALSE apparaît quand la condition n'est pas satisfaite
Rappelons que les opérateurs <- et -> permettent de sauvegarder des objets dans la mémoire de R. Créons un vecteur numérique Age et un vecteur alphanumérique Sexe à travers les commandes suivantes :
Age <- c(19, 31, 28, 18, 25, 23, 27, 20)
Sexe <- c('F', 'H', 'F', 'H', 'H', 'F', 'H', 'F')
Affichons enfin les deux vecteurs avec les commandes :
Age
Sexe
Pour sélectionner une partie d'un vecteur, utilisez '''l'opérateur de sélection''' [ ]. Etudiez les exemples suivants :
X = 10:20
X[3] # Donne le troisième élément du vecteur X
X[c(6,9)] # Donne le sixième et neuvième élément du vecteur X
X[3:5] # Donne le troisième quatrième et cinquième élément du vecteur X
X[7:5] # Donne le septième, le sixième et le cinquième élément du vecteur X
X[-c(4,7)] # Donne X sans le quatrième et septième élément du vecteur X
X[-(1:3)] # Donne X sans les trois premiers éléments
X[(X<15)] # Donne les éléments de X inférieur à 15
X[(X<17) & (X>13)] # Donne les éléments de X inférieurs à 17 ET supérieurs à 13
X[(X<13) | (X>17)] # Donne les éléments de X inférieurs à 13 OU supérieurs à 17
=== Les matrices ===
La matrice est un objet atomique : tous ses éléments sont caractérisés par le même mode (ou type). Pour créer une matrice utilisez la fonction matrix() :
a1 <- matrix(1:6, ncol=2) # a1 est une matrice 3x2
a2 <- matrix(1:6, nrow=2) # a2 est une matrice 2x3
b1 <- matrix(1:6, ncol=2, byrow = TRUE) # b1 est une matrice 3x2
b2 <- matrix(1:6, nrow=2, byrow = TRUE) # b2 est une matrice 2x3
Pour sélectionner une partie d'une matrice, utilisez '''l'opérateur de sélection''' [ ] :
a1[3,2] # Donne l'élément de la matrice a1 qui se situe à la coordonnée [3,2] c'est-à-dire à la troisième ligne et deuxième colonne
a1[2,] # Sélectionne la deuxième ligne de la matrice a1
a1[,2] # Sélectionne la deuxième colonne de la matrice a1
a1[-1,] # Matrice a1 sans sa première ligne
a1[,-1] # Matrice a1 sans sa première colonne
a1[-1,2] # Sélectionne la deuxième colonne de la matrice a1 en excluant la première ligne
a2[,a2[1,]>2] # Sélectionne les colonnes de la matrice a2 pour lesquelles la valeur sur la première ligne est supérieure à 2
=== Les data frames ===
Le data-frame est un tableau des données à 2 dimensions dont les colonnes sont des variables de différents modes. Il s'agit de l'objet qu'il faut privilégier pour la recherche en sciences humaines. En effet, dans la plupart des cas, les bases des données sont composées par des variables qualitatives et quantitatives ! La fonction data.frame() permet de créer cet objet :
Age <- c(19, 31, 28, 18, 25, 23, 27, 20)
Sexe <- c('F', 'H', 'F', 'H', 'H', 'F', 'H', 'F')
Database <- data.frame(Age, Sexe) # Database est un data-frame comportant une variable qualitative et une variable quantitative
Database
Pour sélectionner une variable particulière d’un data-frame, vous pouvez utiliser le symbole '''$''' :
Database$Age
Database$Sexe
De manière analogue aux matrices, vous pouvez sélectionner une partie d’un data-frame en utilisant les '''opérateurs de sélection''' [ ] :
Database[1,2]
Database[1:4,2]
== Charger des jeux des données de R ==
La fonction data() permet de récupérer des bases des données qui existent dans R :
data() # Permet d'afficher les bases des données de R pouvant être récupérées
data(iris) # Permet de charger en mémoire la base des données « iris ».
help(iris) # Lance l’aide associée à la base des données « iris ».
ls() # Remarquons l’existence de l’objet « iris », qui a été chargé en mémoire
iris
La fonction de ces bases de données est strictement pédagogique : elles permettent à l’utilisateur de tester aisément les différentes commandes de R. Nous allons d’ailleurs en servir dans les prochains chapitres.
== Importer des bases des données ==
Les fonctions read.table() et read.csv() permettent de lire et importer  des fichiers .txt et .csv. L'intégration de la fonction file.choose() vous facilitera la tâche...
Database <- read.table("data.txt", header = TRUE) # Le fichier data.txt est lu est stocké dans un nouveau objet R nommé Database
Database <- read.table(file.choose(), header = TRUE, sep = ",") # Le séparateur utilisé dans le fichier délimité est la virgule
Database <- read.csv(file.choose(), header = TRUE, sep= ";") # Le séparateur utilisé dans le fichier csv est le point-virgule
= Traitement des données alphanumériques =
Dans un premiers temps nous explorerons les fonctions de R permettant de manipuler les objets de nature numérique de manière élémentaire. Dans la deuxième partie de ce chapitre, nous présenterons des méthodes quantitatives pouvant être appliquée à l’analyse de discours.
== Manipulations de bas niveau ==
=== Concaténation ===
Pour concaténer, juxtaposer des chaînes de caractères utiliser la fonction paste() :
paste("Bonjour", "!!!")
paste ("Bonjour", "!!!", sep = "_")
paste ("Bonjour", "!!!", sep = "")
x <- c("a", "b", "c")
paste(x,x)
paste(x,x, sep = "_")
paste(x,x, collapse="++")
paste(x,x, sep = "_", collapse="++")
=== Longueur des chaînes de caractères ===
Pour accéder à la longueur de chaînes utiliser la fonction nchar()
Texte1 <- "Bonjour!"
nchar(Texte1, type = "chars")
Texte2 <- c("Bonjour", "à", "vous", "tous", "!")
nchar(Texte2, type = "chars")
=== Extraire/remplacer un segment de chaîne ===
La fonction substr() permet d’extraire un segment de chaîne à partir des attributs « start » et « stop » :
Texte3 <- c("ABCDEFGHI")
substr(Texte3, start = 3, stop = 6)
Texte4 <- c("ABCD", "EFGH", "ILMN", "OPQR")
substr(Texte4, start = 2, stop = 3)
Les opérateurs d’assignation <- et -> permettent de remplacer des segments de chaîne :
substr(Texte3, start = 3, stop = 6) <- "@@@"
Texte3
substr(Texte4, start = 2, stop = 3) <- "##"
Texte4
La fonction substring() permet d’extraire un segment de chaîne à partir des attributs « first » et « last » :
Texte5 <- paste(LETTERS, collapse="")
substring(Texte5, first = 2)
Texte6 <- c("ABCD", "EFGHILMNOPQR")
substring(Texte6, first = 2)
Les opérateurs d’assignation <- et -> permettent de remplacer des segments de chaîne :
substring(Texte5, first = 3, last = 6) <- "@@@"
Texte5
=== Transformations sur une chaîne ===
La fonction tolower() permet de transformer une chaîne de caractère en minuscule :
tolower("BoNjoUr!")
tolower(LETTERS)
La fonction toupper() permet de transformer une chaîne  de caractère en majuscule :
toupper("BoNjoUr!")
toupper(letters)
La fonction chartr() permet de remplacer des lettres dans une chaîne des caractères :
Texte7 <- "cHaInE BiZarRe"
chartr(Texte7, old = "caE", new = "¦@#") # La lettre « c » est remplacée par le symbole ¦, la lettre « a » est remplacée par le symbole @ et la lettre « E » est remplacée par le symbole #.
=== Scinder une chaîne des caractères ===
La fonction strsplit() permet de diviser une chaîne de caractères :
Texte8 <- c("J'aime jouer au football", "Je n'aime pas jouer à hockey sur glace")
strsplit(Texte8, split = " " , fixed = TRUE)
strsplit(Texte8, split = "'" , fixed = TRUE)
strsplit(Texte8, split = "a" , fixed = TRUE)
strsplit(Texte8, split = c("o", "u"), fixed = TRUE)
L’output de la fonction strsplit() est représentée par une liste. Vous pouvez utiliser la fonction unlist() pour créer un vecteur contenant tous les éléments de la liste :
unlist(strsplit(Texte8, split = " " , fixed = TRUE))
=== Rechercher des pattern ===
La fonction grep() permet de rechercher les éléments d’une liste qui présentent un pattern donné
Texte9 <- c("argue", "sténo", "huons", "remet", "ponce", "mites", "ligie", "vitre", "fluée", "floué", "ahana", "fonte", "boche", "tinté", "frime", "tente", "cédez", "votif", "ligné", "acéré")
grep(pattern = "a" , Texte9, value = FALSE, fixed = TRUE) # Donne les indices des éléments de Texte9 qui contiennent la lettre « a »
grep(pattern = "a" , Texte9, value = TRUE, fixed = TRUE) # Donne les éléments de Texte9 qui contiennent la lettre « a »
=== Les expressions régulières ===
Il existe plusieurs symboles qui permettent de faciliter les recherches dans les chaînes de caractères. Il s’agit notamment de :
* ^ : début d’une chaîne
* $ : fin d’une chaîne
* . : tout caractère
* | : disjonction (ou)
* [] : ensemble de caractères à égaler
* [^]: ensemble de caractères à ne pas égaler
* \\ : permet de rechercher des caractères spéciaux (« ? », « $ », « ^ »,…)
* * : 0 fois ou plus l’expression concernée
* + : 1 fois ou plus l’expression concernée
* ? : 0 ou 1 fois l’expression concernée
* {n} : nombre d’apparition de l’expression concernée
* {n,}: l’expression concernée apparaît n fois ou plus
* {,n}: l’expression concernée apparaît n fois ou moins
* () : regroupement
Pour rechercher dans une chaîne de caractères des expressions régulières avec la fonction grep, il faut fixer l’attribut « fixed » à la valeur FALSE :
Texte9 <- c("argue", "sténo", "huons", "remet", "ponce", "mites", "ligie", "vitre", "fluée", "floué", "ahana", "fonte", "boche", "tinté", "frime", "tente", "cédez", "votif", "ligné", "acéré")
grep(pattern = "^a", Texte9, value = TRUE, fixed=FALSE) # Donne les mots qui commencent par la lettre « a »
grep(pattern = "e$", Texte9, value = TRUE, fixed=FALSE) # Donne les mots qui se terminent par la lettre « e »
grep(pattern = "te", Texte9, value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence  « te »
grep(pattern = "n.e", Texte9 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence « n.e »
grep(pattern = "na|ce" , Texte9 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence « na » ou la séquence « ce »
grep(pattern = "n.e|c.e" , Texte9 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence « n.e » ou la séquence « c.e »
grep(pattern = "[cdt]e" , Texte9 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence « ce » ou « de » ou « te »
grep(pattern = "[^cdt]e" , Texte9 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la lettre « e » et qui ne présentent pas les séquences « ce », « de » et « te »
Texte10 <- c("ab","abc", "ababc", "ababab", "abababc" ,"bab","cbabab","abba","abbc","ca","abaabc", "ababbc", "acac")
grep(pattern = "ab*c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : a(b)*c
grep(pattern = "ab+c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : a(b)+ c
grep(pattern = "ab?c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : a(b)? c
grep(pattern = "ab{2}c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : abbc
grep(pattern = "(ab)*c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : (ab)*c
grep(pattern = "(ab)+c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : (ab)+ c
grep(pattern = "(ab)?c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : (ab)? c
grep(pattern = "(ab){2}c" , Texte10 , value = TRUE, fixed=FALSE) # Donne les mots qui contiennent la séquence : ababc
=== Remplacer des pattern ===
La fonction gsub() permet de rechercher et remplacer un pattern dans un objet alphanumérique :
Texte9 <- c("argue", "sténo", "huons", "remet", "ponce", "mites", "ligie", "vitre", "fluée", "floué", "ahana", "fonte", "boche", "tinté", "frime", "tente", "cédez", "votif", "ligné", "acéré")
gsub(pattern = "o" , replacement = "O" , Texte9, fixed = TRUE)
gsub(pattern = "e" , replacement = "E" , Texte9, fixed = TRUE)
== Fouille de textes - text mining ==
= Traitement des données numériques =
== Les opérateurs arithmétiques classiques ==
== Les opérateurs arithmétiques classiques ==


Ligne 328 : Ligne 32 :
== Représenter des données sur R ==
== Représenter des données sur R ==


L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : hist(), density(), lines(), boxplot(), barplot(), pie(),mosaicplot(), assocplot(), plot(), abline(), pairs(), scatterplot3d().
L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : '''''hist(), density(), lines(), boxplot(), barplot(), pie(),mosaicplot(), assocplot(), plot(), abline(), pairs(), scatterplot3d().'''''


=== Histogramme et fonction de densité ===
=== Histogramme et fonction de densité ===


L’histogramme permet de représenter la distribution d’une variable continue. Vous pouvez construire des histogrammes avec la fonction hist() :
L’histogramme permet de représenter la distribution d’une variable continue. Vous pouvez construire des histogrammes avec la fonction '''''hist()''''' :
  data(iris)
  data(iris)
  hist(iris$Sepal.Length, prob = FALSE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Effectif ", col = "lightblue") # Histogramme en effectif
  hist(iris$Sepal.Length, prob = FALSE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Effectif ", col = "lightblue") # Histogramme en effectif
  hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité
  hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité


La fonction density() permet d’obtenir un estimateur à noyau de la densité :
La fonction '''''density()''''' permet d’obtenir un estimateur à noyau de la densité :
  plot(density(iris$Sepal.Length))
  plot(density(iris$Sepal.Length))


Ligne 343 : Ligne 47 :
  hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité
  hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité
  lines(density(iris$Sepal.Length),col="red")
  lines(density(iris$Sepal.Length),col="red")
[[Fichier:Histogramme densité.png|centre|vignette|Histogramme avec la densité |500px]]


=== Boite à moustache ===
=== Boite à moustache ===


La boîte à moustache est une méthode rapide pour représenter et résumer le profil d’une variable continue. Pour créer une boîte à moustache utilisez la fonction boxplot() :
La boîte à moustache est une méthode rapide pour représenter et résumer le profil d’une variable continue. Pour créer une boîte à moustache utilisez la fonction '''''boxplot()''''' :
  A <- rnorm(1000, 100, 10) # A est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 100 et d'écart-type 10
  A <- rnorm(1000, 100, 10) # A est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 100 et d'écart-type 10
  B <- rnorm(1000, 120, 20) # B est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 120 et d'écart-type 20
  B <- rnorm(1000, 120, 20) # B est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 120 et d'écart-type 20
  boxplot(A, main = "Distribution des valeurs générés")
  boxplot(A, main = "Distribution des valeurs générés")
  boxplot(list(A, B), main = "Distribution des valeurs générés" , names = c("µ = 100, sd = 10", "µ = 120, sd = 20 "))
  boxplot(list(A, B), main = "Distribution des valeurs générés" , names = c("µ = 100, sd = 10", "µ = 120, sd = 20 "))
[[Fichier:Boxplot.png|Boites à moustache des vecteurs A et B|500px|centre|vignette]]


=== Diagramme en tuyaux d’orgue ===
=== Diagramme en tuyaux d’orgue ===


Le diagramme en tuyaux d’orgue permet de représenter graphiquement la distribution d'une variable discrète. Pour créer un diagramme en tuyaux d’orgue, utilisez la fonction barplot() :
Le diagramme en tuyaux d’orgue permet de représenter graphiquement la distribution d'une variable discrète. Pour créer un diagramme en tuyaux d’orgue, utilisez la fonction '''''barplot()''''' :
  ventes <- c(200, 102, 32, 120, 310, 152)
  ventes <- c(200, 102, 32, 120, 310, 152)
  names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
  names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
  barplot(ventes, main = "Diagramme des ventes", col = "lightblue")  
  barplot(ventes, main = "Diagramme des ventes", col = "lightblue")  
  barplot(ventes, main = "Diagramme des ventes", col = "lightblue", horiz = TRUE)
  barplot(ventes, main = "Diagramme des ventes", col = "lightblue", horiz = TRUE)
[[Fichier:Barplot.png|centre|vignette|Diagramme en tuyaux d'orgue|500px]]


=== Diagramme circulaire ===
=== Diagramme circulaire ===


Le diagramme circulaire permet de représenter des variables discrètes. Utilisez la fonction pie() pour construire des diagrammes circulaires :
Le diagramme circulaire permet de représenter des variables discrètes. Utilisez la fonction '''''pie()''''' pour construire des diagrammes circulaires :
  ventes <- c(200, 102, 32, 120, 310, 152)
  ventes <- c(200, 102, 32, 120, 310, 152)
  names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
  names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
  pie(ventes, main = "Diagramme des ventes", col = rainbow(length(ventes)))
  pie(ventes, main = "Diagramme des ventes", col = rainbow(length(ventes)))
[[Fichier:Camembert.png|vignette|Diagramme circulaire|500px|centre]]


=== Diagramme empilé ===
=== Diagramme empilé ===


Le diagramme empilé permet de représenter graphiquement les effectifs d’un tableau de contingence. Le diagramme empilé s’obtient au moyen de la fonction barplot() en fournissant un objet de mode matrix :
Le diagramme empilé permet de représenter graphiquement les effectifs d’un tableau de contingence. Le diagramme empilé s’obtient au moyen de la fonction '''''barplot()''''' en fournissant un objet de mode matrix :
  data(HairEyeColor)
  data(HairEyeColor)
  HairEye <- apply(HairEyeColor, c(1, 2), sum)
  HairEye <- apply(HairEyeColor, c(1, 2), sum)
  barplot(HairEye, legend = rownames(HairEye), main = "Diagramme empilé", xlab = "Couleur des yeux")
  barplot(HairEye, legend = rownames(HairEye), main = "Diagramme empilé", xlab = "Couleur des yeux")
[[Fichier:Diagramme empilé.png|vignette|Diagramme empilé|500px|centre]]


=== Diagrammes en mosaïque ===
=== Diagrammes en mosaïque ===


Le diagramme en mosaïque permet de représenter graphiquement les effectifs d’un tableau de contingence. De ce fait, la surface des mosaïques est proportionnelle aux effectifs observés dans les cellules du tableau de contingence. Pour créer un diagramme en mosaïque utilisez la fonction mosaicplot() :
Le diagramme en mosaïque permet de représenter graphiquement les effectifs d’un tableau de contingence. De ce fait, la surface des mosaïques est proportionnelle aux effectifs observés dans les cellules du tableau de contingence. Pour créer un diagramme en mosaïque utilisez la fonction '''''mosaicplot()''''' :
  mosaicplot(HairEye, main = "Diagramme en mosaïque", xlab = "Cheveux", ylab = "Yeux")
  mosaicplot(HairEye, main = "Diagramme en mosaïque", xlab = "Cheveux", ylab = "Yeux")
[[Fichier:Diagrammes en mosaïque.png|vignette|Diagramme en mosaïque|500px|centre]]


=== Graphique d’association ===
=== Graphique d’association ===


Le graphique d’association de Cohen-Friendly indique les déviations par rapport à l’indépendance dans une table de contingence. Utilisez la fonction assocplot() pour créer un graphique d’association :
Le graphique d’association de Cohen-Friendly indique les déviations par rapport à l’indépendance dans une table de contingence. Utilisez la fonction '''''assocplot()''''' pour créer un graphique d’association :
  assocplot(HairEye, main = "Graphique d’association", xlab = "Cheveux", ylab = "Yeux")
  assocplot(HairEye, main = "Graphique d’association", xlab = "Cheveux", ylab = "Yeux")
[[Fichier:Graphique d’association.png|vignette|Graphique d’association|500px|centre]]


=== Nuage des points 2D ===
=== Nuage des points 2D ===


La fonction plot() permet – entre d’autres – de représenter deux variables continues dans un plan cartésien. Exemple :
La fonction '''''plot()''''' permet – entre d’autres – de représenter deux variables continues dans un plan cartésien. Exemple :
  data(USArrests)
  data(USArrests)
  plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
  plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
  abline(lm(USArrests$Murder~USArrests$Assault), col = "red")
  abline(lm(USArrests$Murder~USArrests$Assault), col = "red")


Remarque : la fonction “lm” permet de créer des modèles linéaires (on y reviendra).
Remarque : la fonction “''lm''” permet de créer des modèles linéaires (on y reviendra).
 
[[Fichier:Nuage des points 2D.png|vignette|Nuage des points 2D|500px|centre]]


=== Matrice des scatter plots ===
=== Matrice des scatter plots ===


La fonction pairs() permet de représenter un scatter plot pour chaque couple possible de colonnes d’un dataframe ou d’une matrice donnée :
La fonction '''''pairs()''''' permet de représenter un scatter plot pour chaque couple possible de colonnes d’un dataframe ou d’une matrice donnée :
  data <- USArrests[,c(1,2,4)]
  data <- USArrests[,c(1,2,4)]
  pairs(data)
  pairs(data)
[[Fichier:Matrice des scatter plots.png|vignette|Matrice des scatter plots|500px|centre]]


=== Nuage des points 3D ===
=== Nuage des points 3D ===


La fonction scatterplot3d() permet de représenter trois variables dans un espace tridimensionnel.  Pour utiliser cette fonction il faut installer le package « scatterplot3d » :
La fonction '''''scatterplot3d()''''' permet de représenter trois variables dans un espace tridimensionnel.  Pour utiliser cette fonction il faut installer le package « ''scatterplot3d'' » :
  library(scatterplot3d)
  library(scatterplot3d)
  s3d <- scatterplot3d(USArrests$Assault, USArrests$Rape, USArrests$Murder, type= "h", highlight.3d = TRUE, angle = 45, scale.y = 0.5, pch = 20, main = "Nuage des points 3D", xlab = "Nombre d’agressions", ylab = "  Nombre de viols", zlab = "Nombre d’assassinats")
  s3d <- scatterplot3d(USArrests$Assault, USArrests$Rape, USArrests$Murder, type= "h", highlight.3d = TRUE, angle = 45, scale.y = 0.5, pch = 20, main = "Nuage des points 3D", xlab = "Nombre d’agressions", ylab = "  Nombre de viols", zlab = "Nombre d’assassinats")
  s3d$plane3d(lm(USArrests$Murder ~ USArrests$Assault + USArrests$Rape))
  s3d$plane3d(lm(USArrests$Murder ~ USArrests$Assault + USArrests$Rape))
[[Fichier:Nuage des points 3D.png|vignette|Nuage des points 3D|500px|centre]]


=== Corrgram ===
=== Corrgram ===


La fonction corrgram() permet de représenter graphiquement une matrice de corrélation de manière efficace. Pour utiliser cette fonction il faut installer le package « corrgram » :
La fonction '''''corrgram()''''' permet de représenter graphiquement une matrice de corrélation de manière efficace. Pour utiliser cette fonction il faut installer le package « ''corrgram'' » :
  library(corrgram)
  library(corrgram)
  data(auto)
  data(auto)
  corrgram(auto, order=TRUE, main="Auto data (PC order)")
  corrgram(auto, order=TRUE, main="Auto data (PC order)")
[[Fichier:Corrgram.png|vignette|Corrgram|500px|centre]]


== Traitements statistiques élémentaires ==
== Traitements statistiques élémentaires ==


L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : mean(), sd(), median(), quantile(), min(), max(), summary() et cov().
L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : '''''mean(), sd(), median(), quantile(), min(), max(), summary()''''' et '''''cov()'''''.


=== Mesures de tendance centrale, de dispersion et de position ===
=== Mesures de tendance centrale, de dispersion et de position ===


Les fonctions mean(), sd() restituent la moyenne, et respectivement l’écart-type d’un objet donné :
Les fonctions '''''mean()''''', '''''sd()''''' restituent la moyenne, et respectivement l’écart-type d’un objet donné :
  mean(USArrests$Murder)
  mean(USArrests$Murder)
  sd(USArrests$Murder)
  sd(USArrests$Murder)


Les fonctions median() et quantile() restituent le médian et les quantiles désirées :
Les fonctions '''''median()''''' et '''''quantile()''''' restituent le médian et les quantiles désirées :
  median(USArrests$Murder)
  median(USArrests$Murder)
  quantile(USArrests$Murder, c(0.25, 0.5, 0.75)) # Donne les 3 quartiles
  quantile(USArrests$Murder, c(0.25, 0.5, 0.75)) # Donne les 3 quartiles
  quantile(USArrests$Murder, c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)) # Donne les 9 déciles
  quantile(USArrests$Murder, c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)) # Donne les 9 déciles


Les fonctions min() et max() restituent la valeur minimale et maximale d’un objet :
Les fonctions '''''min()''''' et '''''max()''''' restituent la valeur minimale et maximale d’un objet :
  min(USArrests$Murder)
  min(USArrests$Murder)
  max(USArrests$Murder)
  max(USArrests$Murder)
Ligne 434 : Ligne 159 :
=== Résumé statistique ===
=== Résumé statistique ===


La fonction summary() fournit une série d’information qui varie en fonction de l’objet d’input :
La fonction '''''summary()''''' fournit une série d’information qui varie en fonction de l’objet d’input :
  summary(iris)
  summary(iris)
  summary(USArrests)
  summary(USArrests)
Ligne 440 : Ligne 165 :
=== Matrice de variance-covariance ===
=== Matrice de variance-covariance ===


La fonction var() restitue la matrice de variance-covariance d’une matrice ou d’un data-frame :
La fonction '''''var()''''' restitue la matrice de variance-covariance d’une matrice ou d’un data-frame :
  var(USArrests)
  var(USArrests)


Ligne 447 : Ligne 172 :
=== Corrélation ===
=== Corrélation ===


La fonction cor() restitue la matrice de corrélation d’une matrice ou d’un data-frame :
La fonction '''''cor()''''' restitue la matrice de corrélation d’une matrice ou d’un data-frame :
  cor(USArrests)
  cor(USArrests)


=== Test sur un coefficient de corrélation ===
=== Test sur un coefficient de corrélation ===


La fonction t.test() permet de tester la significativité d’un coefficient de corrélation donnée :
La fonction '''''t.test()''''' permet de tester la significativité d’un coefficient de corrélation donnée :
  x <- c(44.4, 45.9, 41.9, 53.3, 44.7, 44.1, 50.7, 45.2, 60.1)
  x <- c(44.4, 45.9, 41.9, 53.3, 44.7, 44.1, 50.7, 45.2, 60.1)
  y <- c( 2.6,  3.1,  2.5,  5.0,  3.6,  4.0,  5.2,  2.8,  3.8)
  y <- c( 2.6,  3.1,  2.5,  5.0,  3.6,  4.0,  5.2,  2.8,  3.8)
Ligne 459 : Ligne 184 :
=== Régression linéaire simple ===
=== Régression linéaire simple ===


La fonction lm() permet de bâtir de modèles de régression linéaire simple :
La fonction '''''lm()''''' permet de bâtir de modèles de régression linéaire simple :
  plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
  plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
  LinMod4 <- lm(USArrests$Murder~USArrests$Assault)
  LinMod4 <- lm(USArrests$Murder~USArrests$Assault)
Ligne 472 : Ligne 197 :
=== Régression linéaire multiple ===
=== Régression linéaire multiple ===


La fonction lm() permet de bâtir de modèles de régression linéaire multiple.
La fonction '''''lm()''''' permet de bâtir de modèles de régression linéaire multiple :
  data <- USArrests[,c(1,2,4)]
  data <- USArrests[,c(1,2,4)]
  pairs(data)
  pairs(data)
Ligne 479 : Ligne 204 :
  anova(LinMod5)
  anova(LinMod5)


Un modèle linéaire nécessite la normalité des résidus et l'homoscédasticité. Utilisez le code suivant pour vérifier si ces deux conditions sont remplies : par(mfrow = c(2,2))
Un modèle linéaire nécessite la normalité des résidus et l'homoscédasticité. Utilisez le code suivant pour vérifier si ces deux conditions sont remplies :  
par(mfrow = c(2,2))
  plot(LinMod5, col.smooth = "black") # Analyse des résidus
  plot(LinMod5, col.smooth = "black") # Analyse des résidus


=== Analyse en composantes principales ===
== Statistiques inférentielles : t-test, Analyse de variance ==
=== Test de T sur un échantillon unique ===
 
La fonction '''''t.test()''''' permet – entre d’autres – de comparer une moyenne observée à une moyenne théorique.
 
Test bilatéral:
notes <- c(4, 4, 4.5, 3, 5, 6, 5.5, 5, 4, 3.5, 3, 5.5, 4, 6, 5, 5.5)
m.theo <- 4.5
t.test(notes, mu = m.theo)
 
Test unilatéral droit:
m.theo <- 4
t.test(notes, mu = m.theo, alternative = "greater")
 
Test unilatéral gauche:
m.theo <- 5
t.test(notes, mu = m.theo, alternative = "less")
 
Ce test nécessite la normalité des données de l'échantillon. Vous pouvez la tester avec le code suivant ('''Attention!''' Le test de normalité de Shapiro-Wilk a pour hypothèse nulle que l'échantillon est normalement distribué! En résumé, si votre test est significatif, alors la distribution n'est pas normale) :
shapiro.test(notes)
 
=== Test de T sur deux échantillons indépendants avec variance égales ===
 
La fonction '''''t.test()''''' permet – entre d’autres – de comparer deux moyennes issues de deux échantillons indépendants avec variances égales.
 
Test bilatéral:
A <- c(3,4,5,4,3,4,4,4,5,3,3,6,1,2)
B <- c(5,7,6,4,5,3,5,5,3,6,5,5,4,4,4,5,4)
var.test(A,B) # Test sur la variance
t.test(A, B, paired = FALSE, var.qual = TRUE)
 
Test unilatéral droit:
t.test(A, B, paired = FALSE, var.qual = TRUE, alternative = "greater")
 
Test unilatéral gauche:
t.test(A, B, paired = FALSE, var.qual = TRUE, alternative = "less")
 
Ce test nécessite la normalité des données dans chaque sous-population. Vous pouvez la tester avec le code suivant ('''Attention!''' Le test de normalité de Shapiro-Wilk a pour hypothèse nulle que l'échantillon est normalement distribué! En résumé, si votre test est significatif, alors la distribution n'est pas normale) :
shapiro.test(A)
shapiro.test(B)
 
=== Test de T sur deux échantillons indépendants avec variance différente ===
 
La fonction '''''t.test()''''' permet – entre d’autres – de comparer deux moyennes issues de deux échantillons indépendants avec variances différentes (Test de Welch).
 
Test bilatéral:
C <- c(2,4,5,4,2,3,5,4,6,4,2,7,1,2,1,3)
D <- c(5,6,4,5,3,5,6,5,5,4,4,5,4)
var.test(C,D) # Test sur la variance
t.test(C, D, paired = FALSE, var.qual = FALSE)
 
Test unilatéral droit:
t.test(C, D, paired = FALSE, var.qual = FALSE, alternative = "greater")
 
Test unilatéral gauche:
t.test(C, D, paired = FALSE, var.qual = FALSE, alternative = "less")
 
Ce test nécessite la normalité des données dans chaque sous-population. Vous pouvez la tester avec le code suivant :
shapiro.test(C)
shapiro.test(D)
 
=== Test de T sur deux échantillons dépendants ===
 
La fonction '''''t.test()''''' permet – entre d’autres – de comparer deux moyennes issues de deux échantillons dépendants.
 
Test bilatéral:
E <- c(3,4,5,4,3,4,4,4,5,3,3,6,1,2)
F <- c(5,7,6,4,5,3,5,5,3,6,5,5,4,4)
t.test(E, F, paired = TRUE)
 
Test unilatéral droit:
t.test(E, F, paired = TRUE, alternative = "greater")
 
Test unilatéral gauche:
t.test(E, F, paired = TRUE, alternative = "less")
 
Ce test nécessite la normalité dans les scores des différences:
shapiro.test(F-E)
 
=== ANOVA à un critère de classification ===
 
La fonction '''''lm()''''' permet de créer des modèles linéaires. De ce fait, elle peut être utilisée pour construire des modèles ANOVA.
data(InsectSprays)
boxplot(InsectSprays$count ~ InsectSprays$spray)
LinMod1 <-lm(InsectSprays$count ~ InsectSprays$spray)
summary(LinMod1) # Paramètres du modèle
anova(LinMod1) # Tableau de l’ANOVA
 
Condition d’application : normalité des résidus et homoscédasticité
par(mfrow = c(2,2))
plot(LinMod1, col.smooth = "black") # Analyse des résidus
bartlett.test(InsectSprays$count ~ InsectSprays$spray) # Test sur l’homogénéité des variance de Bartlett
library(car)
leveneTest(InsectSprays$count ~ InsectSprays$spray) # Test sur l’homogénéité des variance de Levene. Pour utiliser cette fonction il faut installer le package « car ».
 
=== ANOVA à deux critères de classification ===
 
La fonction '''''lm()''''' permet de créer des modèles linéaires. De ce fait, elle peut être utilisée pour construire des modèles ANOVA :
data(CO2)
boxplot(CO2$uptake ~ CO2$Treatment * CO2$Type)
interaction.plot(CO2$Treatment, CO2$Type, CO2$uptake, main = "Graphique des moyennes", xlab = "Traitement", ylab = "Consommation de CO2", trace.label = "Provenance")
 
Modèle avec interaction (multiplicatif) :
LinMod2 <- lm(CO2$uptake ~ CO2$Treatment * CO2$Type) # Construction du modèle avec interaction (multiplicatif)
summary(LinMod2) # Paramètres du modèle
anova(LinMod2) # Tableau de l’ANOVA
 
Condition d’application : normalité des résidus et homoscédasticité
par(mfrow = c(2,2))
plot(LinMod2, col.smooth = "black") # Analyse des résidus
bartlett.test(CO2$uptake ~ CO2$Treatment * CO2$Type) # Test sur l’homogénéité des variance de Bartlett
library(car)
leveneTest(CO2$uptake ~ CO2$Treatment * CO2$Type) # Test sur l’homogénéité des variance de Levene. Pour utiliser cette fonction il faut installer le package « car ».
 
== Graphes et réseaux ==
 
Il y a deux packages sur R permettant de générer et analyser des réseaux : [http://igraph.sourceforge.net/ igraph] et [http://statnet.org/ statnet]. Ces deux outils présentent des avantages et des désavantages :
* [http://igraph.sourceforge.net/ igraph] permet de représenter les réseaux de manière efficace et élégante. De plus, il s’agit d’un outil intéressant pour génération aléatoire des graphes (simulation). Pour une utilisation de [http://igraph.sourceforge.net/ igraph], vous pouvez consulter la page
** {{ Goblock | [[Analyse de réseaux avec R]] }}
* Contrairement à [http://igraph.sourceforge.net/ igraph], [http://statnet.org/ statnet] permet de faire de la modélisation statistique (voir Exponential random graph models – ERGP).
Nous nous limiterons ici à présenter [http://statnet.org/ statnet].
 
=== Générer un graphe ===
 
Pour créer un graphe, il faut avant tout créer une matrice d’adjacence ou une matrice des arrêts. Générons une matrice d’adjacence avec le code suivant :
 
mat_adjacence <- matrix(round(runif(2500, max = 0.51)), ncol = 50)
 
La matrice des arêtes peut être crée de la manière suivante :
 
depart <- c('A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'D', 'D', 'D', 'D', 'D', 'F', 'G', 'G')
arrive <- c('B', 'C', 'D', 'F', 'G', 'A', 'C', 'G', 'F', 'G', 'A', 'B', 'C', 'F', 'G', 'H', 'B', 'C')
mat_aretes <- cbind(depart,arrive)
 
La fonction '''''as.network()''''' permet de transformer une matrice d’adjacence ou une matrice des arrêts en un objet de type network (un graphe). Pour utiliser cette fonction, il faut charger la librarie statnet :
 
library(statnet)
G1 <- as.network(mat_adjacence)
G2 <- as.network(mat_aretes)
 
Alternativement, nous pouvons générer un graphe aléatoire en définissant le nombre de sommets et sa densité :
 
G3 <- rgraph(20, tprob = 0.1) # G3 est un graphe aléatoire de 20 sommets, avec densité 0.1
 
=== Représenter un graphe ===
 
Les fonctions gplot et gplot3d permettent de générer des graphiques en 2 et 3 dimensions :
 
gplot(G1)
gplot3d(G1)
gplot(G2)
gplot3d(G2)
gplot(G3)
gplot3d(G3)
 
La fonction '''''plot.sociomatrix()''''' permet de représenter de manière efficace la matrice d'adjacence d'un graphe :
 
plot.sociomatrix(G2)
 
=== Indices, indicateurs ===
 
La librairie statnet permet de calculer des indicateurs permettant de décrire les réseaux et leurs éléments.
 
==== Au niveau du réseau ====
 
La fonction gden permet d’obtenir la densité d’un reseau :
 
gden(G1)
gden(G2)
gden(G3)
 
La fonction '''''grecip()''''' permet de calculer le degré de réciprocité d'un réseau :
grecip(G1)
grecip(G2)
grecip(G3)
 
La fonction '''''gtrans()''''' permet d’estimer le niveau de transitivité d’un graphe donné :
 
gtrans(G1)
gtrans(G2)
gtrans(G3)
 
La fonction connectedness d’éstimer le degré de connexité d’un réseau :
connectedness(G1)
connectedness(G2)
connectedness(G3)
 
==== Au niveau des sommets ====
 
La fonction '''''degree()''''' permet d’obtenir le degré de chaque sommet du graphe. L’argument cmode permet de spécifier si on s’intéresse aux degrés entrants (indegree), sortants (outdegree), ou totaux (freeman) :
degree(G1, cmode = "indegree")
degree(G1, cmode = "outdegree")
degree(G1, cmode = "freeman")
 
degree(G2, cmode = "indegree")
degree(G2, cmode = "outdegree")
degree(G2, cmode = "freeman")
 
degree(G3, cmode = "indegree")
degree(G3, cmode = "outdegree")
degree(G3, cmode = "freeman")
 
Lorsqu’on étude un réseau comportant un grand nombre de sommets, on peut étudier le tri à plat des degrés :
table(degree(G1, cmode = "indegree"))
table(degree(G1, cmode = "outdegree"))
table(degree(G1, cmode = "freeman"))
 
La centralité de proximité peut être mesurée à partir de la fonction '''''closeness()''''' :
closeness(G1)
closeness(G2)
closeness(G3)
 
La fonction '''''betweenness()''''' permet d’obtenir la centralité d’intermédiarité :
betweenness(G1)
betweenness(G2)
betweenness(G3)
 
'''''infocent()''''' permet d’évaluer le niveau de centralité de chaque sommet vis-à-vis de la circulation de l’information :
infocent(G1)
infocent(G2)
infocent(G3)
 
Les indices de '''''closeness(), de betweenness(), infocent()''''' peuvent être représentées sur la représentation du réseau :
gplot(G2, vertex.cex = closeness (G2) * 3, main = " closeness ")
gplot(G2, vertex.cex = betweenness(G2) * 0.6, main = "betweenness")
gplot(G2, vertex.cex = infocent (G2) * 1.3, main = " infocent ")
 
La fonction '''''geodist()$count''''' permet de compter le nombre de chemins possibles entre chaque paire de sommets du réseau :
geodist(G2)$count
La fonction '''''geodist()$gdist''''' indique la distance entre chaque paire de sommets du sommet. La distance se définie par la longueur d’un plus court chemin.
geodist(G2)$gdist
 
=== Analyse de réseaux ===
 
* {{ Goblock | [[Analyse de réseaux avec R]] }}
 
== Liens ==


== Statistiques inférentielles : t-test, ANOVA ==
=== Packages utiles pour l'analyse statistique ===
* Rcmdr : interface graphique de R , http://socserv.mcmaster.ca/jfox/Misc/Rcmdr/
* OpenMx : outil permettant de générer et évaluer des modèles à équations structurales , http://openmx.psyc.virginia.edu/
* igraph : outil permettant de créer et analyser des graphes et des réseaux , http://igraph.sourceforge.net/
* statnet : outil permettant de créer et analyser des graphes et des réseaux , http://statnet.csde.washington.edu/
* lattice : outil permettant de générer des représentations graphiques avancées , http://lmdvr.r-forge.r-project.org/figures/figures.html
* R.matlab : outil permettant d’importer des fichiers Matlab sur R , http://cran.r-project.org/web/packages/R.matlab/R.matlab.pdf
* R2HTML : outil permettant d'exporter les outputs de R en HTML , http://cran.r-project.org/web/packages/R2HTML/R2HTML.pdf
* corrgram : outil permettant de représenter graphiquement des matrices de corrélations , http://cran.r-project.org/web/packages/corrgram/corrgram.pdf
* 3dscatterplot : outil permettant à créer des graphiques 3D , http://cran.r-project.org/web/packages/scatterplot3d/scatterplot3d.pdf
* [http://lavaan.ugent.be/lavaan lavaan]: latent variable analysis
* [http://sachaepskamp.com/semPlot semPlot]: outil pour visualiser des modèles SEM, http://cran.r-project.org/web/packages/semPlot/index.html


= Théorie des graphes sur R =
=== Autres tutoriels ===


= Programmation et structures de contrôle =
* [http://www.unige.ch/ses/sococ/cl/r/toc.html Tutoriels R de E.Horber] (UniGE)
* [http://www.statmethods.net/ Statmethods.net] (Quick-R)


= Bibliographie =
[[Utilisateur:Cereghd0|Cereghd0]] 9 janvier 2013 à 12:27 (CET)


* Adler, J. (2011). R, L’essentiel. Pearson.
[[Category: Analytique et exploration de données]]
* Chevalier, B. (2005). Logiciels libres Open source : qu'est-ce que c'est ? Paris : H & K.
[[Category: R]]
* Cornillon, P.A. (2010). Statistiques avec R (2ème édition augmentée). Rennes : Presses Universitaires de Rennes.
* Fox, J. The R Commander: A Basic-Statistics Graphical User Interface to R. http://www.jstatsoft.org/v14/i09/paper
* Howell, D. (1998). Méthodes statistiques en sciences humaines. Bruxelles : Editions De Boeck Université.
* Huillet, J. Initiation à l’environnement R. http://cict.fr/~stpierre/doc-R.pdf
* Jean, B. (2011). Du bon usage des licences libres. Framasoft (coll. Framabook).
* Millot, G. (2008). Comprendre et réaliser les tests statistiques à l’aide de R (1ère édition). Bruxelles : Editions De Boeck Université.
* Smets-Solanes, J.P. (1999). Logiciels libres : liberté, égalité, business. Paris : Edispher.

Dernière version du 7 décembre 2022 à 12:13

Tutoriels R
Module: Tutoriels R
◀▬
⚐ à finaliser ☸
⚒ 2022/12/07
Voir aussi
Catégorie: Tutoriels R

Introduction

Cet article fournit un tutoriel conçis sur le traitement des données numériques avec R. Une explication plus conceptuelle sur le fonctionnement de R pour les analyses est disponible dans la page Introduction à la modélisation des données avec R.

Les opérateurs arithmétiques classiques

La somme : + 

3+5

La soustraction : - 

5-1

La multiplication : * 

3*2

La division : / 

8/2

L’exposant : ^ 

3^3

La racine carrée : sqrt() 

sqrt(9)

Le modulo (donne le reste d’une division) : %% 

10%%3

Représenter des données sur R

L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : hist(), density(), lines(), boxplot(), barplot(), pie(),mosaicplot(), assocplot(), plot(), abline(), pairs(), scatterplot3d().

Histogramme et fonction de densité

L’histogramme permet de représenter la distribution d’une variable continue. Vous pouvez construire des histogrammes avec la fonction hist() : 

data(iris)
hist(iris$Sepal.Length, prob = FALSE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Effectif ", col = "lightblue") # Histogramme en effectif
hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité

La fonction density() permet d’obtenir un estimateur à noyau de la densité : 

plot(density(iris$Sepal.Length))

Pour tracer l'histogramme et la densité en même temps on peut utiliser le code suivant : 

hist(iris$Sepal.Length, prob = TRUE, main = "Histogramme de la longueur des sépales", xlab = "Longueur des sépales", ylab = "Densité de la distribution", col = "lightblue") # Histogramme en densité
lines(density(iris$Sepal.Length),col="red")
Histogramme avec la densité

Boite à moustache

La boîte à moustache est une méthode rapide pour représenter et résumer le profil d’une variable continue. Pour créer une boîte à moustache utilisez la fonction boxplot() : 

A <- rnorm(1000, 100, 10) # A est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 100 et d'écart-type 10
B <- rnorm(1000, 120, 20) # B est un vecteur de 1000 valeurs tirées d'une distribution gaussienne de moyenne 120 et d'écart-type 20
boxplot(A, main = "Distribution des valeurs générés")
boxplot(list(A, B), main = "Distribution des valeurs générés" , names = c("µ = 100, sd = 10", "µ = 120, sd = 20 "))
Boites à moustache des vecteurs A et B

Diagramme en tuyaux d’orgue

Le diagramme en tuyaux d’orgue permet de représenter graphiquement la distribution d'une variable discrète. Pour créer un diagramme en tuyaux d’orgue, utilisez la fonction barplot() : 

ventes <- c(200, 102, 32, 120, 310, 152)
names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
barplot(ventes, main = "Diagramme des ventes", col = "lightblue") 
barplot(ventes, main = "Diagramme des ventes", col = "lightblue", horiz = TRUE)
Diagramme en tuyaux d'orgue

Diagramme circulaire

Le diagramme circulaire permet de représenter des variables discrètes. Utilisez la fonction pie() pour construire des diagrammes circulaires : 

ventes <- c(200, 102, 32, 120, 310, 152)
names(ventes) <- c("Pomme","Cerise", "Abricot", "Poire", "Framboise", "Melon")
pie(ventes, main = "Diagramme des ventes", col = rainbow(length(ventes)))
Diagramme circulaire

Diagramme empilé

Le diagramme empilé permet de représenter graphiquement les effectifs d’un tableau de contingence. Le diagramme empilé s’obtient au moyen de la fonction barplot() en fournissant un objet de mode matrix : 

data(HairEyeColor)
HairEye <- apply(HairEyeColor, c(1, 2), sum)
barplot(HairEye, legend = rownames(HairEye), main = "Diagramme empilé", xlab = "Couleur des yeux")
Diagramme empilé

Diagrammes en mosaïque

Le diagramme en mosaïque permet de représenter graphiquement les effectifs d’un tableau de contingence. De ce fait, la surface des mosaïques est proportionnelle aux effectifs observés dans les cellules du tableau de contingence. Pour créer un diagramme en mosaïque utilisez la fonction mosaicplot() : 

mosaicplot(HairEye, main = "Diagramme en mosaïque", xlab = "Cheveux", ylab = "Yeux")
Diagramme en mosaïque

Graphique d’association

Le graphique d’association de Cohen-Friendly indique les déviations par rapport à l’indépendance dans une table de contingence. Utilisez la fonction assocplot() pour créer un graphique d’association : 

assocplot(HairEye, main = "Graphique d’association", xlab = "Cheveux", ylab = "Yeux")
Graphique d’association

Nuage des points 2D

La fonction plot() permet – entre d’autres – de représenter deux variables continues dans un plan cartésien. Exemple : 

data(USArrests)
plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
abline(lm(USArrests$Murder~USArrests$Assault), col = "red")

Remarque : la fonction “lm” permet de créer des modèles linéaires (on y reviendra).

Nuage des points 2D

Matrice des scatter plots

La fonction pairs() permet de représenter un scatter plot pour chaque couple possible de colonnes d’un dataframe ou d’une matrice donnée : 

data <- USArrests[,c(1,2,4)]
pairs(data)
Matrice des scatter plots

Nuage des points 3D

La fonction scatterplot3d() permet de représenter trois variables dans un espace tridimensionnel. Pour utiliser cette fonction il faut installer le package « scatterplot3d » : 

library(scatterplot3d)
s3d <- scatterplot3d(USArrests$Assault, USArrests$Rape, USArrests$Murder, type= "h", highlight.3d = TRUE, angle = 45, scale.y = 0.5, pch = 20, main = "Nuage des points 3D", xlab = "Nombre d’agressions", ylab = "  Nombre de viols", zlab = "Nombre d’assassinats")
s3d$plane3d(lm(USArrests$Murder ~ USArrests$Assault + USArrests$Rape))
Nuage des points 3D

Corrgram

La fonction corrgram() permet de représenter graphiquement une matrice de corrélation de manière efficace. Pour utiliser cette fonction il faut installer le package « corrgram » : 

library(corrgram)
data(auto)
corrgram(auto, order=TRUE, main="Auto data (PC order)")
Corrgram

Traitements statistiques élémentaires

L’objectif de ce chapitre est d’apprendre à utiliser les fonctions : mean(), sd(), median(), quantile(), min(), max(), summary() et cov().

Mesures de tendance centrale, de dispersion et de position

Les fonctions mean(), sd() restituent la moyenne, et respectivement l’écart-type d’un objet donné : 

mean(USArrests$Murder)
sd(USArrests$Murder)

Les fonctions median() et quantile() restituent le médian et les quantiles désirées : 

median(USArrests$Murder)
quantile(USArrests$Murder, c(0.25, 0.5, 0.75)) # Donne les 3 quartiles
quantile(USArrests$Murder, c(0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9)) # Donne les 9 déciles

Les fonctions min() et max() restituent la valeur minimale et maximale d’un objet : 

min(USArrests$Murder)
max(USArrests$Murder)

Résumé statistique

La fonction summary() fournit une série d’information qui varie en fonction de l’objet d’input : 

summary(iris)
summary(USArrests)

Matrice de variance-covariance

La fonction var() restitue la matrice de variance-covariance d’une matrice ou d’un data-frame : 

var(USArrests)

Approches corrélationnels

Corrélation

La fonction cor() restitue la matrice de corrélation d’une matrice ou d’un data-frame : 

cor(USArrests)

Test sur un coefficient de corrélation

La fonction t.test() permet de tester la significativité d’un coefficient de corrélation donnée : 

x <- c(44.4, 45.9, 41.9, 53.3, 44.7, 44.1, 50.7, 45.2, 60.1)
y <- c( 2.6,  3.1,  2.5,  5.0,  3.6,  4.0,  5.2,  2.8,  3.8)
cor.test(x,y)

Régression linéaire simple

La fonction lm() permet de bâtir de modèles de régression linéaire simple : 

plot(USArrests$Murder~USArrests$Assault, main = " Nuage de points", xlab = "Nombre d’agressions", ylab = "Nombre d’assassinats")
LinMod4 <- lm(USArrests$Murder~USArrests$Assault)
summary(LinMod4) # Paramètres du modèle
anova(LinMod4)
abline(LinMod4, col= "red")

Un modèle linéaire nécessite la normalité des résidus et l'homoscédasticité. Utilisez le code suivant pour vérifier si ces deux conditions sont remplies : 

par(mfrow = c(2,2))
plot(LinMod4, col.smooth = "black") # Analyse des résidus

Régression linéaire multiple

La fonction lm() permet de bâtir de modèles de régression linéaire multiple : 

data <- USArrests[,c(1,2,4)]
pairs(data)
LinMod5 <- lm(USArrests$Murder ~ USArrests$Assault + USArrests$Rape)
summary(LinMod5) # Paramètres du modèle
anova(LinMod5)

Un modèle linéaire nécessite la normalité des résidus et l'homoscédasticité. Utilisez le code suivant pour vérifier si ces deux conditions sont remplies : 

par(mfrow = c(2,2))
plot(LinMod5, col.smooth = "black") # Analyse des résidus

Statistiques inférentielles : t-test, Analyse de variance

Test de T sur un échantillon unique

La fonction t.test() permet – entre d’autres – de comparer une moyenne observée à une moyenne théorique.

Test bilatéral: 

notes <- c(4, 4, 4.5, 3, 5, 6, 5.5, 5, 4, 3.5, 3, 5.5, 4, 6, 5, 5.5)
m.theo <- 4.5
t.test(notes, mu = m.theo)

Test unilatéral droit: 

m.theo <- 4
t.test(notes, mu = m.theo, alternative = "greater")

Test unilatéral gauche: 

m.theo <- 5
t.test(notes, mu = m.theo, alternative = "less")

Ce test nécessite la normalité des données de l'échantillon. Vous pouvez la tester avec le code suivant (Attention! Le test de normalité de Shapiro-Wilk a pour hypothèse nulle que l'échantillon est normalement distribué! En résumé, si votre test est significatif, alors la distribution n'est pas normale) : 

shapiro.test(notes)

Test de T sur deux échantillons indépendants avec variance égales

La fonction t.test() permet – entre d’autres – de comparer deux moyennes issues de deux échantillons indépendants avec variances égales.

Test bilatéral: 

A <- c(3,4,5,4,3,4,4,4,5,3,3,6,1,2)
B <- c(5,7,6,4,5,3,5,5,3,6,5,5,4,4,4,5,4)
var.test(A,B) # Test sur la variance
t.test(A, B, paired = FALSE, var.qual = TRUE)

Test unilatéral droit: 

t.test(A, B, paired = FALSE, var.qual = TRUE, alternative = "greater")

Test unilatéral gauche: 

t.test(A, B, paired = FALSE, var.qual = TRUE, alternative = "less")

Ce test nécessite la normalité des données dans chaque sous-population. Vous pouvez la tester avec le code suivant (Attention! Le test de normalité de Shapiro-Wilk a pour hypothèse nulle que l'échantillon est normalement distribué! En résumé, si votre test est significatif, alors la distribution n'est pas normale) : 

shapiro.test(A)
shapiro.test(B)

Test de T sur deux échantillons indépendants avec variance différente

La fonction t.test() permet – entre d’autres – de comparer deux moyennes issues de deux échantillons indépendants avec variances différentes (Test de Welch).

Test bilatéral: 

C <- c(2,4,5,4,2,3,5,4,6,4,2,7,1,2,1,3)
D <- c(5,6,4,5,3,5,6,5,5,4,4,5,4)
var.test(C,D) # Test sur la variance
t.test(C, D, paired = FALSE, var.qual = FALSE)

Test unilatéral droit: 

t.test(C, D, paired = FALSE, var.qual = FALSE, alternative = "greater")

Test unilatéral gauche: 

t.test(C, D, paired = FALSE, var.qual = FALSE, alternative = "less")

Ce test nécessite la normalité des données dans chaque sous-population. Vous pouvez la tester avec le code suivant : 

shapiro.test(C)
shapiro.test(D)

Test de T sur deux échantillons dépendants

La fonction t.test() permet – entre d’autres – de comparer deux moyennes issues de deux échantillons dépendants.

Test bilatéral: 

E <- c(3,4,5,4,3,4,4,4,5,3,3,6,1,2)
F <- c(5,7,6,4,5,3,5,5,3,6,5,5,4,4)
t.test(E, F, paired = TRUE)

Test unilatéral droit: 

t.test(E, F, paired = TRUE, alternative = "greater")

Test unilatéral gauche: 

t.test(E, F, paired = TRUE, alternative = "less")

Ce test nécessite la normalité dans les scores des différences: 

shapiro.test(F-E)

ANOVA à un critère de classification

La fonction lm() permet de créer des modèles linéaires. De ce fait, elle peut être utilisée pour construire des modèles ANOVA. 

data(InsectSprays)
boxplot(InsectSprays$count ~ InsectSprays$spray)
LinMod1 <-lm(InsectSprays$count ~ InsectSprays$spray)
summary(LinMod1) # Paramètres du modèle
anova(LinMod1) # Tableau de l’ANOVA

Condition d’application : normalité des résidus et homoscédasticité 

par(mfrow = c(2,2))
plot(LinMod1, col.smooth = "black") # Analyse des résidus
bartlett.test(InsectSprays$count ~ InsectSprays$spray) # Test sur l’homogénéité des variance de Bartlett
library(car)
leveneTest(InsectSprays$count ~ InsectSprays$spray) # Test sur l’homogénéité des variance de Levene. Pour utiliser cette fonction il faut installer le package « car ».

ANOVA à deux critères de classification

La fonction lm() permet de créer des modèles linéaires. De ce fait, elle peut être utilisée pour construire des modèles ANOVA : 

data(CO2)
boxplot(CO2$uptake ~ CO2$Treatment * CO2$Type)
interaction.plot(CO2$Treatment, CO2$Type, CO2$uptake, main = "Graphique des moyennes", xlab = "Traitement", ylab = "Consommation de CO2", trace.label = "Provenance")

Modèle avec interaction (multiplicatif) : 

LinMod2 <- lm(CO2$uptake ~ CO2$Treatment * CO2$Type) # Construction du modèle avec interaction (multiplicatif)
summary(LinMod2) # Paramètres du modèle
anova(LinMod2) # Tableau de l’ANOVA

Condition d’application : normalité des résidus et homoscédasticité 

par(mfrow = c(2,2))
plot(LinMod2, col.smooth = "black") # Analyse des résidus
bartlett.test(CO2$uptake ~ CO2$Treatment * CO2$Type) # Test sur l’homogénéité des variance de Bartlett
library(car)
leveneTest(CO2$uptake ~ CO2$Treatment * CO2$Type) # Test sur l’homogénéité des variance de Levene. Pour utiliser cette fonction il faut installer le package « car ».

Graphes et réseaux

Il y a deux packages sur R permettant de générer et analyser des réseaux : igraph et statnet. Ces deux outils présentent des avantages et des désavantages :

  • igraph permet de représenter les réseaux de manière efficace et élégante. De plus, il s’agit d’un outil intéressant pour génération aléatoire des graphes (simulation). Pour une utilisation de igraph, vous pouvez consulter la page
  • Contrairement à igraph, statnet permet de faire de la modélisation statistique (voir Exponential random graph models – ERGP).

Nous nous limiterons ici à présenter statnet.

Générer un graphe

Pour créer un graphe, il faut avant tout créer une matrice d’adjacence ou une matrice des arrêts. Générons une matrice d’adjacence avec le code suivant : 

mat_adjacence <- matrix(round(runif(2500, max = 0.51)), ncol = 50)

La matrice des arêtes peut être crée de la manière suivante : 

depart <- c('A', 'A', 'A', 'A', 'A', 'B', 'B', 'B', 'C', 'C', 'D', 'D', 'D', 'D', 'D', 'F', 'G', 'G')
arrive <- c('B', 'C', 'D', 'F', 'G', 'A', 'C', 'G', 'F', 'G', 'A', 'B', 'C', 'F', 'G', 'H', 'B', 'C')
mat_aretes <- cbind(depart,arrive)

La fonction as.network() permet de transformer une matrice d’adjacence ou une matrice des arrêts en un objet de type network (un graphe). Pour utiliser cette fonction, il faut charger la librarie statnet : 

library(statnet)
G1 <- as.network(mat_adjacence)
G2 <- as.network(mat_aretes)

Alternativement, nous pouvons générer un graphe aléatoire en définissant le nombre de sommets et sa densité : 

G3 <- rgraph(20, tprob = 0.1) # G3 est un graphe aléatoire de 20 sommets, avec densité 0.1

Représenter un graphe

Les fonctions gplot et gplot3d permettent de générer des graphiques en 2 et 3 dimensions : 

gplot(G1)
gplot3d(G1)
gplot(G2)
gplot3d(G2)
gplot(G3)
gplot3d(G3)

La fonction plot.sociomatrix() permet de représenter de manière efficace la matrice d'adjacence d'un graphe : 

plot.sociomatrix(G2)

Indices, indicateurs

La librairie statnet permet de calculer des indicateurs permettant de décrire les réseaux et leurs éléments.

Au niveau du réseau

La fonction gden permet d’obtenir la densité d’un reseau : 

gden(G1)
gden(G2)
gden(G3)

La fonction grecip() permet de calculer le degré de réciprocité d'un réseau : 

grecip(G1)
grecip(G2)
grecip(G3)

La fonction gtrans() permet d’estimer le niveau de transitivité d’un graphe donné : 

gtrans(G1)
gtrans(G2)
gtrans(G3)

La fonction connectedness d’éstimer le degré de connexité d’un réseau : 

connectedness(G1)
connectedness(G2)
connectedness(G3)

Au niveau des sommets

La fonction degree() permet d’obtenir le degré de chaque sommet du graphe. L’argument cmode permet de spécifier si on s’intéresse aux degrés entrants (indegree), sortants (outdegree), ou totaux (freeman) : 

degree(G1, cmode = "indegree")
degree(G1, cmode = "outdegree")
degree(G1, cmode = "freeman")

degree(G2, cmode = "indegree")
degree(G2, cmode = "outdegree")
degree(G2, cmode = "freeman")

degree(G3, cmode = "indegree")
degree(G3, cmode = "outdegree")
degree(G3, cmode = "freeman")

Lorsqu’on étude un réseau comportant un grand nombre de sommets, on peut étudier le tri à plat des degrés : 

table(degree(G1, cmode = "indegree"))
table(degree(G1, cmode = "outdegree"))
table(degree(G1, cmode = "freeman"))

La centralité de proximité peut être mesurée à partir de la fonction closeness() : 

closeness(G1)
closeness(G2)
closeness(G3)

La fonction betweenness() permet d’obtenir la centralité d’intermédiarité : 

betweenness(G1)
betweenness(G2)
betweenness(G3)

infocent() permet d’évaluer le niveau de centralité de chaque sommet vis-à-vis de la circulation de l’information : 

infocent(G1)
infocent(G2)
infocent(G3)

Les indices de closeness(), de betweenness(), infocent() peuvent être représentées sur la représentation du réseau : 

gplot(G2, vertex.cex = closeness (G2) * 3, main = " closeness ")
gplot(G2, vertex.cex = betweenness(G2) * 0.6, main = "betweenness")
gplot(G2, vertex.cex = infocent (G2) * 1.3, main = " infocent ")

La fonction geodist()$count permet de compter le nombre de chemins possibles entre chaque paire de sommets du réseau : 

geodist(G2)$count

La fonction geodist()$gdist indique la distance entre chaque paire de sommets du sommet. La distance se définie par la longueur d’un plus court chemin. 

geodist(G2)$gdist

Analyse de réseaux

Liens

Packages utiles pour l'analyse statistique

Autres tutoriels

Cereghd0 9 janvier 2013 à 12:27 (CET)

Récupérée de « https://edutechwiki.unige.ch/fmediawiki/index.php?title=Analyses_statistiques_avec_R&oldid=167628 »