Support de Cours sur le logiciel R
1 Introduction générale 1
2 Introduction sur R 1
3 La session R 1
4 Les objets, création et types 2
4.1 Création . . . 2
4.2 Affichage de la valeur d’un objet . . . 2
4.3 Les différents types d’un objet . . . 2
4.4 La valeur manquante . . . 3
4.5 Suppression d’objets . . . 3
4.6 Les attributs . . . 3
5 Les opérateurs arithmétiques 4 6 Les opérateurs logiques 4 7 Les vecteurs 4 7.1 Définition et construction . . . 4
7.2 Arithmétique . . . 5
7.3 Quelques opérations . . . 5
7.4 Les vecteurs de caractères . . . 5
7.5 Les vecteurs logiques . . . 5
7.6 Sélection d’une partie d’un vecteur . . . 6
7.6.1 Sélection par des vecteurs d’entiers positifs . . . 6
7.6.2 Sélection par des vecteurs d’entiers négatifs . . . 6
7.6.3 Sélection par des vecteurs de logique . . . 6
7.6.4 Cas classiques . . . 6
8 Les facteurs 7 8.1 Création . . . 7
8.2 Quelques fonctions sur les facteurs . . . 7
8.3 Quelques remarques sur la conversion en numérique des facteurs . . . 8
9 Les dates 8 10 Les Matrices 8 10.1 Création . . . 8 10.2 Sélection . . . 9 10.3 Opérations particulières . . . 9 10.3.1 Algèbre linéaire . . . 9 10.3.2 Fonctions utiles . . . 9
10.4 Les tableaux “array” . . . 9
11 Les listes 10 11.1 Création, extraction . . . 10
11.2 Listes : utilité et quelques fonctions . . . 10
11.3 Listes particulières : dimnames . . . 10
12 Les “Data Frame” 11 12.1 Création, extraction . . . 11 13 Attach et detach (data frame et listes) 11
14.1 Import de données . . . 11
14.2 Import de script et fonctions . . . 11
14.3 Export de données . . . 12
15 La programmation 12 16 Les fonctions 12 16.1 Définition, appel . . . 12
16.2 Les fonctions, arguments . . . 13
17 Les graphiques 13 17.1 Introduction . . . 13
17.2 Personnalisation des graphiques . . . 13
17.3 Exemples de fonctions et d’options des graphiques . . . 14
18 Formules sous R 14 18.1 Formules sous R . . . 14
18.2 Formules sous R, transformation des variables . . . 15
18.3 Formules sous R, transformation et protection . . . 15
18.4 Formules sous R, Interaction, effets nidés . . . 15
18.5 Formules sous R, Facteurs . . . 15
18.6 Formules sous R, Contrastes et facteurs . . . 16
18.7 Formules sous R, Contrastes et facteurs . . . 16
18.8 Codage des facteurs . . . 16
18.9 Codage des facteurs, suite . . . 17
19 Modélisations, quelques exemples 17
20 Règles de recherches des objets 17
21 Librairies de programmes (packages) 18
22 Rien ne marche ? 18
Support de Cours sur le logiciel R Master de Statistique Appliquée
avertissement : cette présentation n’est pas un cours mais simplement un support de cours. Les explications sont succinctes voire inexistantes et les exemples sont encore plus rares... Les erreurs de typographie seront sûrement rencontrées quelque-part, en dernier lieu l’aide en ligne a toujours raison...
1
Introduction générale
R est un logiciel de la famille GNU La présentation de la page http://www.gnu.org en français est citée ci-dessous.
Le projet GNU a été lancé en 1984 afin de développer un système d’exploitation complet, semblable à Unix et qui soit un logiciel libre : le système GNU. (« GNU » est l’acronyme récursif the « GNU’s Not Unix » ; on le prononce « gnou »avec un G audible). Des variantes du système d’exploitation GNU, basées sur le noyau « Linux », sont utilisées largement à présent ; bien que ces systèmes soient communément appelés par le terme « Linux », ils le seraient plus exactement par « GNU/Linux ».
Les logiciels GNU sont nombreux et divers comme les compilateurs C, C++ et fortran (gcc), les librai-ries, les éditeurs de textes (emacs), les environnements (GNOME), les logiciels de calcul scientifique (octave), l’édition (TEX, LATEX) les jeux d’échec (chess) etc..
R (ou GNU-R) est un logiciel de statistiques interactif et interprété. Il fourni un langage de commande très souple et qui est ouvert : il possède des interface vers d’autres programmes comme C et Fortran. En outre il est le proche cousin de Splus qui est un logiciel payant. Il permet entre autre
– la manipulation de données, les opérations mathématiques classiques (cos, sin etc...), les nombres complexes, les données discrètes, l’algèbre linéaire
– les techniques statistiques comme, la régression, les modèles GLM, la régression non-linéaire, le bootstrap, les arbres hiérarchiques, les arbres de régression, les techniques multivariées, les nombres aléatoires et les distributions, les séries chronologiques etc...
– les représentation graphiques histogrammes, diagrammes en bâton, boxplot, camemberts, lissage, arbres, dessins 2D et 3D, courbes de niveaux, dessins conditionnels etc...
La page de présentation de R est http://www.R-project.org ; elle permet de télécharger le logiciel gratuitement, de suivre ses évolutions d’avoir des réponses aux questions fréquemment posées (FAQ en anglais)...
2
Introduction sur R
– R utilise des commandes
– Les commandes font intervenir des opérateurs et des fonctions – les commandes opèrent sur des objets
Pour appeler des fonction intégrées il suffit de taper son nom suivi de ses arguments entre parenthèses : > sqrt(x) (racine carrée)
> mean(x) (moyenne)
> help(mean) (aide en ligne sur la fonction, ici la moyenne mean)
> help.start() (lancement de l’aide “graphique” au format html - plus convivial) > q() (quitte R)
3
La session R
Lorsque l’on ouvre le logiciel R, on dit que R ouvre une session. Il cherche une trace éventuelle d’une session antérieure gardée sous la forme de fichier “image” au format interne de R. Si il en trouve une il la charge et vous retrouvez les objets et fonctions de votre précédente session. Sinon aucun objet n’est présent. Pour consulter la liste des objets disponibles tapez un des deux ordres suivants
> objects() > ls()
Il est quelquefois utile de n’afficher que les objets contenant une certaine suite de caractère, par exemple tout ceux qui commance par a
> ls(pattern="^a")
Tous les objets créés lors de la session sont stockés dans un fichier “image” et à votre sortie R vous demande si il faut ou non le garder. On peut stocker une image de manière intentionnelle en utilisant (sous windows) le menu file/save. Cela permet de séparer les fichiers stockant des objets R appartenant à des projets différents. Pour les récupérer il suffit d’utiliser le menu file/load.
Il est fortement conseillé de séparer vos objets en autant d’image que vous avez de projets différents, par exemple le projet Rhône-Alpes, formation R, etc...
4
Les objets, création et types
4.1 Création
Simplement par affectation avec les opérateurs <-, -> en lui donnant un nom : > b <- sqrt(2) (crée l’objet b)
> x<-b (x reçoit la valeur b) > x=b (x reçoit la valeur b) > b -> x (x reçoit la valeur b)
Si un objet n’existe pas l’affectation le crée. Sinon l’affectation écrase la valeur précédente.
4.2 Affichage de la valeur d’un objet
> a (affiche le contenu de a)
> q (affiche le contenu de la fonction q qui permet de quitter) > print(a) (affiche le contenu de a)
4.3 Les différents types d’un objet
– Objets simples (ou atomiques) : ce sont des objets qui ne comportent que des éléments de même mode
– Objets composés (ou hétérogènes) : ce sont des objets qui comportent des éléments qui peuvent être de modes différents
Les principaux modes sont – null (objet vide) : NULL
– logical (booleen) : TRUE, FALSE ou T, F
– numeric (valeur numérique) : 1, 2.3222, pi, 1e-10, – character (chaîne de caractère) : ’bonjour’, "K" – complex (nombre complexe) : 2+0i, 2i
Les conversions d’un mode à un autre de manière explicite – as.logical
– as.numeric – as.complex – as.character
Les conversions d’un mode à un autre de manière implicite se font dans cet ordre – logiques
– numériques – complexes – caractères
Il est possible de tester un objet pour savoir si il est d’un mode particulier, le résultat est vrai ou faux, c’est à dire un booléen (TRUE ou FALSE) :
– is.null(x) – is.logival(x) – is.numeric(x) – is.complex(x) – is.character(x) 4.4 La valeur manquante
Elle est notée NA. Ce n’est pas un véritable mode car elle peut être dans des objets atomiques, mais elle distingue la valeur manquante et possède ses propres règles de calcul. Par exemple
> NA+1 renvoie NA...
Pour savoir si il existe une valeur manquante au moins dans l’objet x il faut poser la question > is.na(x), cela renvoie un objet simple de booléen de même longueur que x.
Dans un objet simple la question est posée élément par élément ; ainsi dans le cas d’un vecteur cela renvoie un vecteur de même longueur que x avec des T si l’élément correspondant de x est NA et des F sinon.
Il existe aussi les valeurs spéciales Inf pour l’infini et NaN pour not a number, valeurs résultants de problèmes calculatoire (par exemple exp(1e10) ou log(-2) dans l’ordre).
4.5 Suppression d’objets
Par défaut R garde tous les objets crées dans la session, sauf si l’on ne sauvegarde pas la session à la sortie de R. Il est donc recommandé de faire souvent le “ménage”. Pour supprimer un objet nommé a > rm(a)
Pour supprimer des objets > rm(a,b)
Enfin pour supprimer une liste d’objets qui possède une partie de nom en commun, ici la lettre a, on utilise
> rm(list=ls(pattern=".*a.*"))
4.6 Les attributs
Les attributs intrinsèques (toujours présents) – Mode (mode)
– Longueur (length)
Les attributs spécifiques qui varient selon le type d’objet – dim, dimnames (voir 11.3)
– classe
Comment les voir ? > attributes(objet) Comment les modifier ?
> attr(objet,"dim")<-c(10,10) Attribut classe (class)
– Permet à une fonction de connaître la classe de l’objet : lorsqu’une fonction (générique) possède plusieurs méthodes différentes selon la classe. Par exemple l’ordre plot(x) ne donne pas le même résultat (ici il s’agit d’un dessin) selon que x est un facteur (classe factor) ou un vecteur de numérique contenant les mêmes valeurs (voir 7 p.4 et 8 p.7).
5
Les opérateurs arithmétiques
parenthèses () exponentiation ^ moins unaire
-séquence :
division entière, congruence %/% %% multiplication, division * /
addition +
-affectation <- ->
Le tableau est ordonné du plus prioritaire (en haut) vers le moins prioritaire (en bas).
6
Les opérateurs logiques
– Comparaison : supérieur (strictement) > supérieur >= inférieur (strictement) < inférieur <= différent != égal ==
dans un ensemble %in%1
– Relation :
négation (not) ! et logique (and) &, && ou logique (or) |, || ou exclusif (xor) xor(,)
7
Les vecteurs
7.1 Définition et construction
C’est un objet atomique composé d’un ensemble ordonné de valeurs (les composantes ou coordonnées ou éléments). Le nombre d’éléments constitue l’attribut longueur.
Construction : différentes méthodes sont possibles dont : – Construction par la fonction collecteur c()
> x<-c(10.4,5.6,12,78,42.3) vecteur de numériques à 5 éléments > x<-c(x,10,23,c(12,15,46),x) vecteur à 20 éléments
Une constante est un vecteur de longueur 1
> x<-c(’A’,’CVER’) vecteur de caractères à 2 éléments > x<-c(TRUE, FALSE) vecteur de logiques à 2 éléments – Construction par l’opérateur séquence :
> 1:30 génère le vecteur c(1,2,...,30) – Construction par la fonction seq()
> seq(1,30,by=0.5) c(1,1.5,2,2.5,...,30)
> seq(1,30,length=300) 300 points compris entre 1 et 30 et équidistants. – Construction par la fonction rep()
> rep(1,4) génère le vecteur c(1,1,1,1)
– Construction par la fonction scan(), R demande alors de rentrer le premier élément, puis le second ... – par conversion explicite : as.vector()
1. il ne s’agit pas d’un opérateur logique habituel : x%in%y prend tous les elements 1 par 1 de x et regarde si ils sont égaux à une des coordonnées de y (au moins), si oui la coordonnée du resultat est TRUE sinon FALSE. Le resultat renvoyé a donc autant de coordonnées que le vecteur x
Remarque on peut poser la question à R si l’objet est un vecteur > is.vector(x) et la réponse est TRUE ou FALSE.
7.2 Arithmétique
Les vecteurs peuvent être utilisés dans des expressions arithmétiques. Les opérations sont effectuées élément par élément et si les vecteurs sont de longueur différentes, le résultat possède la longueur du plus long :
x = -1 0 1 4 y = 2 1 2
y rallongé = 2 1 2 (2 1 2) x+y = 1 1 3 6
En particulier une constante est répétée !
> x*12 multiplie par 12 tous les éléments de x. > x+2 ajoute 2 à tous les éléments de x.
7.3 Quelques opérations
– valeur absolue abs() – racine carrée sqrt()
– trigonométrie cos(), sin(), tan(), asin(), acos(), atan() – exponentielle exp, log(), log10()
– statistiques max(), min(), range(), mean(), median(), var(), IQR(), quantile(), sd(), cov(), cor()
– somme produit sum(), prod(), diff(), cumsum(), cumprod(), cummin(), cummax() – tri sort() order() rank()
– renverse rev()
– arrondis round(x,digits=2), floor(), signif()
– mathématiques beta(), gamma(), choose(), factorial(), digamma(), psigamma()
7.4 Les vecteurs de caractères
Création par les fonctions seq(), rep(), c()
Création par la fonction format(1:12) qui permet la mise en forme des données numériques (chaîne de caractère de même longueur), voir aussi toString()
Manipulations – concaténation : paste() > paste(c(’X’,’Y’),1:10,’txt’,sep=’.’,collapse=NULL) donne c(’X.1.txt’, ’Y.2.txt’, ’X.3.txt’,..., ’X.9.txt’, ’Y.10.txt’) > paste(c(’X’,’Y’),1:10,sep=’.’,collapse="hop") donne "X.1hopY.2hopX.3hopY.4hopX.5hopY.6hopX.7hopY.8hopX.9hopY.10" – extraction : substr() > substr("abcdef",2,4) donne "bcd"
7.5 Les vecteurs logiques
Ce sont des booléens et sont en général générés par des conditions grâce aux opérateurs logiques. Ils peuvent être aussi générés par les fonctions seq(),rep(), c(). Ils permettent des sélections complexes (voir 7.6.3 p.6) ou des opérations de conditions (voir 15 p.12).
> 1>0 Vecteur logique de longueur 1 : TRUE
> x>13 vecteur logique de même longueur que x. Ses éléments ont la valeur T quand l’élément corres-pondant satisfait la condition (ici supérieur à 13) et la valeur F s’il ne la satisfait pas (donc ici inférieur ou égal à 13).
Utilisation en arithmétique ordinaire : les F sont transformés en 0 et les T sont transformés en 1 : > x <- -1:1 (vecteur (-1,0,1))
> test <- x>0 (vecteur (F,F,T)) > (1+x^2)*(x>0) (vecteur (0,0,2)) On peut aussi utiliser les fonctions
> all(test) renvoie un booléen : TRUE si tous les éléments de test sont vrais ou FALSE sinon (ici c’est faux)
> any(test) renvoie un booléen : TRUE si au moins 1 des éléments de test est vrai ou renvoie faux sinon (ici c’est vrai)
7.6 Sélection d’une partie d’un vecteur
Elle s’opère avec l’opérateur de sélection [] et un vecteur comme ceci : > x[vecteur]
Le vecteur peut être soit un vecteur d’entiers positifs, soit un vecteur d’entiers négatifs, soit vecteur de logiques.
7.6.1 Sélection par des vecteurs d’entiers positifs
Les entiers sont les indices des éléments à sélectionner et doivent être compris entre 1 et length(x) La longueur du vecteur d’indice peut être quelconque et sa longueur donne la longueur du résultat : > v<-1:100
> v[6] donne le sixième élément de v : 6
> v[6:8] donne les 6ème, 7ème et 8ème éléments de v
> v[c(6,6,5,1:2)] donne les 6ème, 6ème, 5ème, 1er et 2ème éléments de v > v[10:1] donne les 10ème, 9ème ... 1er éléments de v.
7.6.2 Sélection par des vecteurs d’entiers négatifs Le vecteur indique les indices des éléments à exclure du résultat : > v[-(1:5)] donne v sans ses 5 premiers éléments.
Remarque : on ne peut pas mélanger des indices positifs et négatifs... 7.6.3 Sélection par des vecteurs de logique
Elle constitue un des points commun avec des langages de script comme octave et permet l’extraction d’élément particulier que l’on sait caractérisé par un périphrase (comme “l’élément qui possède une valeur inférieure à 40 mais supérieure à 33.5”) qui peut se traduire en condition logique :
> v<-1:100
> v[(v>40)&(v<33.5)] : les éléments de v qui possèdent une valeur inférieure à 40 et supérieure à 33.5
> v[v%%5==0] donne les éléments de v multiples de 5
Afin de comprendre ce qui se passe décomposons la commande en 2 parties : > v%%5==0 : F F F F T F F F F T F ...
> v
1 2 3 4 5 6 7 8 9 10 11 ...
Le résultat ne garde que les valeurs en regard des valeurs vraies (T) : 5, 10 etc.. 7.6.4 Cas classiques
Nous pouvons substituer à un sous ensemble sélectionné, des valeurs nouvelles : > x[is.na(x)]<-0 les éléments NA reçoivent la valeur 0
y”, ce qui est équivalent à l’ordre suivant : > y<-abs(y)
Recherche de valeur(s) dans un ensemble %in% > ensemble <- c(1990, 1994, 1995, 1997) > tous <- seq(min(x), max(x))
> bool.presents <- tous %in% x > val.absents <- tous[!all.x %in% x] Recherche de la coordonnée du plus petit élément > (1:length)[x==min(x)] # choix 1
> which(x==min(x)) # choix 2 > which.min(x) # choix 3
Recherche des coordonnées des valeurs manquantes NA > which[is.na(x)]
8
Les facteurs
Ce sont des vecteurs ayant 2 attributs supplémentaires permettant la manipulation de données qua-litatives. Les facteurs forment une classe d’objet et bénéficieront donc de traitement particulier pour certaines fonctions par exemple plot().
8.1 Création
2 types différents
– les facteurs non ordonnés (mâle, femelle) appelés factor – les facteurs ordonnés (riche, aisé, pauvre) appelés ordered Leurs attributs
– length, mode "character" – levels
– class : "factor" (ou "ordered" "factor", la classe "ordered" est un raffinement de la classe "fac-tor")
Création
> factor(donnees <,levels,label>) < ... > sont des arguments optionnels > ordered(donnees)
> as.factor(donnees) conversion explicite > as.ordered(donnees) conversion explicite
> cut coupe en classe de longueur (presque) égale une variable continue (voir aussi co.intervals pour des classes d’effectifs presque égaux)
Remarque on peut poser la question à R si l’objet est un facteur > is.factor(x) et la réponse est TRUE ou FALSE.
> is.ordered(x) et la réponse est TRUE ou FALSE.
8.2 Quelques fonctions sur les facteurs
– levels donne les niveaux du facteurs
– unclass rend réel un facteur (recode le premier niveau par 1, le second par 2...), garde les attributs (4.6, p.3 ; 8.1 p.7)
– table(facteur1,facteur2...) donne la table de contingence associée
– tapply(vecteur,facteur,FUN) applique la fonction FUN au vecteur mais séparément, niveau par niveau du facteur
– aggregate(vecteur,list(facteur1,facteur2),FUN=mean) applique la fonction moyenne au vec-teur mais séparément, niveau par niveau du facvec-teur1 puis à l’intérieur niveau par niveau du facvec-teur2 (“équivalent” à l’ordre by de SAS), voir aussi la fonction by().
– split(vecteur,facteur) sépare le vecteur de données grâce au facteur. Tous les niveau 1 du facteur sont ensembles puis tous les niveaux 2 etc... La sortie est une liste (voir 11).
8.3 Quelques remarques sur la conversion en numérique des facteurs
> x<-factor(c(10,11,13)) > as.numeric(unclass(x)) [1] 1 2 3 > as.numeric(x) [1] 1 2 3 > as.numeric(as.vector(x)) [1] 10 11 13 > as.vector(x) [1] "10" "11" "13"
9
Les dates
Il s’agit d’objet homogène d’une classe particulière, la classe date. Pour passer d’un vecteur de caractère à un vecteur de dates de type 25-01-2005, utiliser
> as.Date(x, format = "%d-%m-%Y")
Pour changer de format de date et passer à un format de type 01/25/05 on utilis > format(x,"%m/%d/%y")
Pour en savoir plus, consulter l’aide help(Date).
10
Les Matrices
Les matrices sont des objets atomiques (même mode pour toutes les valeurs) dont les éléments sont organisés en lignes et en colonnes (dans cet ordre). Elles possèdent donc 1 attribut de dimension (dim). Elles possèdent aussi un attribut optionnel dimnames (voir 11.3)
L’attribut length est le nombre total d’éléments et le mode celui de chacun de ses éléments.
10.1 Création
– par la fonction matrix
> m<-matrix(1:8,nrow=2) rangement par colonne (par défaut) m : 1 3 5 7
2 4 6 8
> m<-matrix(1:8,ncol=4,byrow=T) rangement par ligne (argument byrow=T) m : 1 2 3 4
5 6 7 8
> zero<-matrix(0,2,4) matrice (2×4) remplies de 0. – Par conversion explicite
> v<-as.matrix(1:3) donne la matrice (3×1) v :
1 2 3
Remarque on peut poser la question à R si l’objet est une matrice > is.matrix(x) et la réponse est TRUE ou FALSE.
10.2 Sélection
– Les entiers positifs :
> m[1,] donne la première ligne : c’est un vecteur !
> m[1,,drop=F] donne la première ligne sous la forme d’une matrice uniligne.
> m[,c(2,2,1)] donne la seconde, la seconde et la première colonne : c’est une matrice (2×3). – Les entiers négatifs :
> m[-1,] donne la matrice m sauf la première ligne, ici c’est un vecteur.
> m[1:2,-1] donne les 2 premières colonnes de la matrice m sauf la première colonne. – Les logiques :
On peut utiliser une sélection par des vecteurs de logique (sur des lignes ou sur des colonnes) : > m[,m[1,]>2] : toutes les colonnes de m dont les éléments de la première ligne sont supérieurs à 2. On peut utiliser une sélection par une matrice de logique :
> m[m>2] donne un vecteur de tous les éléments de m qui sont supérieurs à 2. > m[m>2]<-NA affecte la valeur NA à tous les éléments de m qui sont supérieurs à 2.
10.3 Opérations particulières
Remarque le produit X*Y est l’opération (ici produit) élément par élément des 2 matrices, de même que la somme, l’exponentiation, le log, le sinus etc..
10.3.1 Algèbre linéaire
X%*%Y produit de matrices t(X) transposition diag(5) Identité d’ordre 5
diag(vec) matrice diagonale avec les valeurs du vecteur vec dans la diagonale crossprod(X,Y) produit croisé (t(X)%*%Y)
svd(X) décomposition en valeurs singulières
eigen(X,symmetric=T) diagonalisation d’une matrice, option matrice symétrique solve(X,Y) inversion de matrice et résolution de système linéaire chol(Y) décomposition de Cholesky
qr(Y) décomposition QR
10.3.2 Fonctions utiles – Dimensions
dim(X), nrow(X), ncol(X) donnent les dimensions, le nombre de lignes et de colonnes de X, ren-voient NULL si c’est un vecteur.
– Concaténation par colonne : cbind, par ligne rbind
– 1 opération à faire par ligne (1ère des 2 dimensions) ou par colonne (2ème des 2 dimensions) Somme par colonne : apply(X,2,sum)
Moyenne par ligne : apply(X,1,mean)
Application de la fonction f(arg1,arg2,arg3) qui prend 3 arguments en entrée dont le premier est un vecteur (qui sera chacune des lignes successivement) : apply(X,1,FUN=f,valarg2,valarg3) – sweep(mat,2,ecartype,FUN=’/’) permet de diviser (multiplier, soustraire etc...) chacune des
co-lonnes (ou ligne) par un élément d’un vecteur (par exemple le vecteur des écart types par colonne, pour réduire une matrice)
10.4 Les tableaux “array”
11
Les listes
La liste est un objet hétérogène. C’est donc un ensemble ordonné d’objets qui ne sont pas forcément tous du même mode ni de même longueur. Les objets sont appelés composants de la liste. Remarquons que
– les composants peuvent être de mode 6=, – les composants peuvent avoir un nom, – la liste n’est pas une classe.
11.1 Création, extraction
Création
> tablev <- c("Paris","Lyon")
> liste <- list(1:3,ville=tablev) les composants peuvent avoir 1 nom
> as.list(1:5) conversion explicite, forme une liste à 5 éléments, qui sont des vecteurs numériques de longueur 1, égaux respectivement à 1, 2, 3, 4 5.
Remarque : on peut poser la question à R si l’objet est une liste > is.list(x) et la réponse est TRUE ou FALSE.
Extraction
> maliste[[2]] : 1ème composante de la liste ville
> maliste$ville : 2ème composante de la liste (si la composante possède 1 nom) > maliste[[1]][1] : 1er élément de la composante 1
> maliste$ville[1] : 1er élément de la composante “ville” (si le composant possède 1 nom) Attributs
– Intrinsèques mode (i.e. comme les modes peuvent être différents il y a un mode spécial, le mode "list"), length (i.e. le nombre de composants)
– names
11.2 Listes : utilité et quelques fonctions
Une liste est souvent retournée comme résultat par des fonctions résidantes lm(), glm(), aov(), eigen()...
Quelques fonctions utiles
> lapply : applique une fonction successivement à chacune des composantes (comme la moyenne, la variance etc...)
> length : nombre de composantes
> unlist(maliste) : remet la liste en vecteur (dans le mode le plus bas en priorité) > c(liste1,liste2) : fusion des 2 listes
11.3 Listes particulières : dimnames
Définition : attribut optionnel d’une matrice et qui contient dans une liste à deux composantes les noms des lignes et des colonnes.
Exemple :
> X <- matrix(don,n,p)
> dimnames(X)<-list(c("ligne1",...,"lignen"),c("col1",...,"colp")) Modification :
> dimnames(X)<-list(NULL,dimnames(X)[[2]]) Sélection de lignes et/ou de colonnes grâce aux dimnames :
12
Les “Data Frame”
Définition : Liste de classe "data frame" dont chacune des composantes est de même longueur (ou pour les matrice de même nombre de lignes). Les modes bien sûr peuvent être différents
12.1 Création, extraction
Création :
> data.frame(mat1,vect,facteur,mat2...) > read.table("nom_du_fichier")
> as.data.frame(toto) par conversion explicite Extraction :
On peut utiliser la méthode pour les listes ou celle pour les matrices : dframe[[5]], dframe$nomcomp,ou dframe[,5] ou enfin dframe[,"nomcomp"].
Remarques :
– On peut poser la question à R si l’objet est un “data-frame” > is.data.frame(x) et la réponse est TRUE ou FALSE.
– Pour transformer une matrice en data frame : data.matrix(dframe) – Résumé numérique du data frame : summary(dframe)
– Entrée au clavier ou correction (version ?) > dframe <- data.entry(dframe)
13
Attach et detach (data frame et listes)
> attach(dframe,pos=2) permet de s’affranchir du nom du data frame et de travailler directement avec le nom de ses composantes (en supposant que dans le répertoire en position 1 il n’y a rien de même nom ; pour la notion de position voir (20, p. 17)) :
> dframe$facteur ⇔ facteur
> facteur <- 2 crée alors une variable facteur de valeur 2 dans le répertoire en position 1. Pour actualiser facteur il faut faire
> dframe$facteur <- 2
> detach(dframe) permet de détacher le data frame Remarque : il est aussi possible d’attacher/détacher des listes.
14
Import - Export
14.1 Import de données
◦ le plus basique : scan() (en cas de difficultés ou pour réduire le temps d’accès) ◦ > entree<-scan("nomfich",what="",sep=";")
> entree vecteur caractère lu dans un fichier ASCII à séparateur “ ;” ◦ lecture évoluée vers 1 data frame (voie normale)
> entree<-read.table("nomfich",sep=";",header=TRUE) – transforme les caractères en facteurs
– transforme les numériques ayant peu de valeurs différentes en facteur
– Vérifier le mode de chacune des composantes (summary puis data.matrix, as.numeric(as.vector()) ou as.integer())
Voir aussi les nombreuses options de read.table() scan().
14.2 Import de script et fonctions
Utiliser un éditeur de texte (wordpad, textpad, notepad, emacs...) permet de taper ses commandes ou ses fonctions en bénéficiant des fonctionnalités d’un éditeur (couper/coller, deplacement à la souris, remplacer, rechercher etc...). Pour importer un série d’ordres R il suffit ensuite de
– couper coller la zone interessante
– si l’on souhaite importer un fichier entier d’ordre > source(’C:/../nomdufichier’)
Pour 1 fonction contenue dans 1 fichier il est possible d’utiliser les ordres > mafonction<-dget(’nomfichier’) (import de la fonction)
> dput(lafonction,’C:/../nomfichier’) (export de la fonction)
Le fichier contenant la fonction commence toujours par function(arg1,arg2) ...
Pour de meilleure fonctionnalité voir le logiciel GNU-Emacs avec le “package” ESS (gratuits).
14.3 Export de données
◦ le plus basique : write() ◦ sortie évoluée vers 1 data frame
> sortie<-write.table(objet,"nomfich",row.names = TRUE, col.names = TRUE)
15
La programmation
◦ Commandes groupées {expr1 ; expr2 ; ...} ◦ if (condition) {
.... } else
expr2 (où expr2 peut être une expression groupée...)
Si le booléen condition est vrai alors le premier groupe d’expression est effectué sinon le deuxième (la condition else est optionnelle)
◦ Boucles
– for (i in vecteur) { .... } – while (condition) {
.... }
Tant que le booléen condition est vrai les expressions {...} sont effectuées. Dès que la condition est fausse les expressions {...} ne sont plus effectuées. La condition est évaluée en tête de boucle. – repeat {
....
if (condition) break ...}
repeat permet de répéter indéfiniment les ordres {...}. – break permet une sortie anticipée des boucles
– next permet d’aller à la boucle suivante : retour direct vers le départ de la boucle, ie for, while ou repeat
16
Les fonctions
16.1 Définition, appel ◦ exemple simple > mafonc<-function(arg1,...) expr > "%!%"<-function(arg1,...) expr ◦ plus complet > mafonc<-function(arg1,arg2) { + resu <- arg1+arg2◦ Attention aux variables globales ! ! ! > mafonc<-function(arg1,arg2) {
+ resu <- arg1+arg2
+ resu<- resu + i (→variable non définie, à éviter !) + return(resu) }
◦ appel de la fonction : > mafonc(2,5) ou équivalent à > mafonc(arg1=2,arg2=5) ou encore
> mafonc(arg2=5,arg1=2)
16.2 Les fonctions, arguments
◦ Arguments par défaut
> mafonc<-function(arg1,arg2=4) ◦ appel de la fonction : > mafonc(arg1=2)
l’argument 2 est pris par défaut égal à 4 > mafonc(2,5) ou équivalent à > mafonc(arg1=2,arg2=5) ou encore > mafonc(arg2=5,arg1=2) ◦ Arguments supplémentaires > mafonc(arg1=2,...)
17
Les graphiques
17.1 Introduction◦ Ouverture/Fermeture du “graphic device” : X11() / dev.off()
◦ Dessin de points (type ’p’) en rond (pch=o) en 2D :
> plot(1:10,1:10,type=’p’,pch=o) (dans l’ordre abscisses puis ordonnées) ◦ Dessin de labels (nom des points)
> plot(1:10,1:10,type=’n’) (mise en place, aucun dessin grâce à type none)
> text(1:10,1:10,paste(’pt’,1:10,sep=’’) (ajout du texte pt1...pt10 aux coord. 1 :10,1 :10) ◦ Amélioration
> plot(1:10,1:10,type="l",main="Mon Titre") ◦ Histogramme d’un echantillon aléatoire (normal)
> hist(rnorm(100), main="Histogramme",prob=T)
◦ Autres types : dotchart, piechart, barplot, boxplot, stars, pairs, coplot, interaction.plot, persp...
17.2 Personnalisation des graphiques
Voir la fonction par (taper help(par)) ! Ci dessous quelques petits exemples > par(mfrow=c(3,2)) 3 graphiques en lignes et 2 en colonnes (6 en tout), voir aussi layout(matrice,widths=w,heights=h)
> par(ask=T) demande confirmation à chaque nouveau dessin
> par(new=F) surimpose le nouveau dessin sur l’ancien (attention aux axes !)
> par(fg=’blue’,bg=’#f2a1c2’) foreground en bleu et background en RGB #f2a1c2 (sorte de rose)
> plot(1:10,2:11,xlim=(0,15),ylim=c(1,16)) dessins de points axes limités entre 0 et 15 (abs-cisse),et entre 1 et 16 (ordonnées)
> matlines(c(1,12),c(1,12),col=2,lty=2) ligne ajoutée au graphique précédent de couleur 2 et type 2 (pointillé).
17.3 Exemples de fonctions et d’options des graphiques
plot(x) Trace le graphe des valeurs de x ordonnées sur l’axe des abscisses plot(x,y) Trace le graphe de y en fonction de x
sunflowerplot(x,y) Idem mais les points superposés sont dessinés sous forme de fleurs dont le nombre de pétales correspond au nombre de points pie(x) Trace un graphe en camembert
boxplot(x) Trace le graphe en "boîtes et moustaches" de x stripplot(x) Trace le graphe des valeurs de x sur une ligne interaction.plot(f1,f2,x,
fun=mean)
Trace le graphe des moyennes de x en fonction des valeurs des facteurs f1 (sur l’axe des abscisses) et f2 (plusieurs graphes) coplot(x∼y|z) Trace le graphe bivarié de x et y pour chaque valeur de z (ou un
petit intervalle de valeurs de z)
matplot(x,y) Trace le graphe bivarié de la 1ère colonne de x contre la 1ère co-lonne de y, la 2ème coco-lonne de x contre la 2ème coco-lonne de y.. pairs(x) Si x est une matrice ou un data.frame, tracer tous les graphes
bivariés entre les colonnes de x
plot.ts(x), ts.plot(x) Trace le graphe d’une série temporelle x en fonction du temps hist(x,freq=T) Trace un histogramme de x
barplot(x) Trace un diagramme en barre (ou bande) des valeurs de x
qqnorm(x) Trace les quantiles de x en fonction de ceux attendus d’une loi normale
qqplot(x,y) Trace les quantiles de y en fonction de ceux de x contour(x,y,z) Trace des courbes de niveau
filled.contour(x,y,z) Idem mais les aires entre les contours sont colorées, voir aussi image(x,y,z)
persp(x,y,z) Idem mais en 3D, voir demo(persp)
symbols(x,y,...) Dessiner aux coordonnées données par x et y des symboles (étoiles, cercles, boxplots...)
Les principales options pour les fonctions graphiques sont résumées ci-dessous. axes=TRUE ou FALSE Si TRUE, les axes et le cadre sont tracés
type="n","p","l","b,"h","s"... Précise le type de graphe dessiné. type="n" supprime le graphe col="blue", col.axis, col.main... Précise la couleur du graphe, des axes, du titre...
bg="red" Précise la couleur du fond xlim=c(0,10),ylim=c(0,20) Précise les limites des axes xlab="axe x",ylab="axe y" Précise les annotations des axes main="titre" Précise le titre du graphe sub="sstitre" Précise le sous-titre du graphe
bty="n","o"... Contrôle comment le cadre est tracé. bty="n" supprime le cadre cex=1.5, cex.axis, cex.main... Contrôle la taille des caractères
font=1, font.axis... Précise la police du texte
las="0" Contrôle l’orientation des annotations des axes lty="1" Contrôle le type de lignes tracées
lwd=1.5 Contrôle la largeur des lignes
pch="+","o"... Contrôle le type de symbole utilisé pour le tracé des points ps=1.5 Contrôle la taille en points du texte et des symboles tck, tcl Précise la longueur des graduations sur les axes
mfcol=c(3,2), mfrow=c(3,2) Partitionne le graphe en 3 lignes et 2 colonnes. Les figures sont remplies colonnes par colonnes ou lignes par lignes
18
Formules sous R
18.1 Formules sous R
– Exemple de la régression > lm(carb~Wt+Disp,data=mtcars) ⇔ carb = α |{z} implicite +β1W t + β2Disp + ε |{z} implicite
Les données proviennent du tableau mtcars – Suppression de l’ordonnée à l’origine
> carb~-1+Wt+Disp
⇔ carb = β1W t + β2Disp + ε
|{z}
implicite 18.2 Formules sous R, transformation des variables
– Transformation continue classique : log, exp, sin , atan... > log(carb)~Wt+Disp
– Transformation en binaire
> Age>40 c’est une variable qui prend la valeur 0 si Age< 40 et 1 sinon. – Transformation en facteur
> cut(Age,3) découpe de la variable Age en 3 intervalle de longueur égale (ou presque) – Transformation en polynôme orthogonaux :
> poly(Age,degree=3)
18.3 Formules sous R, transformation et protection
Transformation et protection
certains signes (*, ^, /) possèdent des valeurs différentes dans une formule et dans un calcul arith-métique. Pour revenir à une signification arithmétique il suffit d’utiliser une protection I()
> I(Age^2) cela permet d’élever Age au carré
> log(Age^2) dans un autre fonction arithmétique pas besoin de protection !
18.4 Formules sous R, Interaction, effets nidés
– Interaction
> Salaire~Sexe+Age+Sexe:Age
⇔ Salaire = α |{z}
implicite
+β1Sexe + β2Age + β3Sexe ∗ Age + ε
|{z}
implicite
> Salaire~Sexe*Age (autre syntaxe équivalent mais plus courte) – Effets nidés
> Y~region+Dpt%in%region
> Y~region/Dpt (autre syntaxe équivalent mais plus courte)
18.5 Formules sous R, Facteurs
– Introduction
yij = µ + αi+ εij
µ moyenne générale
αi effet du facteur A au niveau i
– Surparamétrisation Même le modèle le plus simple est surparamétrisé yij = µ + αi+ εij = µ + β | {z } nouveau µ + (α − β) | {z } nouvel αi
→ il faut rajouter des contraintes : – µ = 0 pas d’intercept (option "-1") – P
iαi= 0 écart p/p µ ("somme")
– α1= 0 écart p/p niveau 1 ("témoin")
18.6 Formules sous R, Contrastes et facteurs
– En conclusion
Le facteur A est représenté par (µ, α1, · · · , αI 5i + 1) coefficients et 1 contrainte linéaire qui relie les
coefficients entre eux
X
λiαi = 0
– Algèbre linéaire :
I + 1 vecteurs reliés par une contrainte linéaire ↔ I vecteurs indépendants Nouveaux coefficients µ∗, α∗1, · · · , α∗I+1
Passage des nouveaux aux anciens par µ α1 .. . αI = C0 µ∗ α∗1 .. . α∗I−1
Généralement µ = µ∗. Les coefficients µ, α1, ...αI seront en général différents selon le type de
contrainte choisies et c’est normal.
18.7 Formules sous R, Contrastes et facteurs
Sous R la matrice C des contrastes ou C0 sa transposée se calcule comme > contr.treatment(levels(facteur))
> contr.sum(levels(facteur)) > contr.helmert(levels(facteur)) > contr.poly(levels(facteur))
18.8 Codage des facteurs
fact : facteur à I modalités. Soit αi le coefficient associé au ième niveau du facteur fact.
Affectation d’un contraste
– Contraste de type “somme” PI
i=1αi = 0 :
> contrasts(fact)<-contr.sum(levels(fact)) > fact<-C(fact,sum) (autre syntaxe)
– Contraste de type “traitement-témoin” α1= 0 (Par défaut pour les factor))
> contrasts(fact)<-contr.treatment(levels(fact)) > fact<-C(fact,treatment) (autre syntaxe)
– Contraste polynomial (Par défaut pour les ordered) > contrasts(fact)<-contr.poly(levels(fact)) > fact<-C(fact,poly) (autre syntaxe)
18.9 Codage des facteurs, suite
– Voir la valeur d’un contraste > contrasts(fact)
– contrasts est un attribut de fact : > attributes(fact)
– contrast renvoie une matrice de contraste Attention au s ! !
Changement ponctuel (dans un modèle) – Dans un modèle lm
> lm(y~a+b,contrasts=list(a="contr.sum",b="contr.poly"),data=dframe) le facteur a du data frame dframe possède un contraste “sum”
le facteur b du data frame dframe possède un contraste “poly”
19
Modélisations, quelques exemples
En général les ordres sont les mêmes quelque soit la modélisation choisie. – calcul du modèle
res<-lm(y~x1+x2) – résumé d’un modèle
summary(res) – dessin d’un modèle
plot(res)
– extraction des résidus residuals(res)
– extraction des coefficients coefficients(res) – prédiction du modèle
predict(res)
De nombreuses autres options sont disponibles en fonction des modèles, par exemple pour deux modèles linéaires le résumé donne aussi la matrice de corrélation estimée des coefficients
summary(res,cor=T)
Nous pouvons comparer des modèles par AIC extractAIC(res) ou par anova aov(res,res1). Le choix de modèle peut être fait par des méthodes ascendantes ou descendantes (step). Les modèles d’arbre de régression ou de discrimination offrent aussi de nombreuses fonctions particulières :
library(rpart) (bibliothèque de programmes pour les arbres qui doivent êtres chargés. D’autres bibliothèques existent, taper library() pour voir celles disponibles sur votre machine)
res<-rpart(y~., data=mesdonnees) (le point “.” signifie que l’on prend toutes les autres variables de mesdonnees autres que y).
plot(res) text(res)
snip.rpart(res)...
20
Règles de recherches des objets
Les objets sont par défaut stockés dans la session courante .GlobalEnv, qui est tout simplement un fichier au format de R (extension .Rd).
Quand on utilise une fonction ou un objet, R recherche dans les fichiers, les data frames attachés, les listes attachées ou les répertoires (par exemple ceux contenant les fonctions résidantes ou les biblio-thèques de programme “library”) selon 1 ordre fixé. La position pos détermine l’ordre de préséance. Pour consulter cet ordre il suffit de taper
> search()
[1] ".GlobalEnv" "package:methods" "package:stats" [4] "package:graphics" "package:grDevices" "package:utils" [7] "package:datasets" "Autoloads" "package:base"
Ainsi dans cet exemple si l’on utilise x, R va chercher sa valeur dans le premier de la liste : .GlobalEnv qui est la session courante. Si il ne trouve pas x il va chercher sa valeur comme une variable du data frame mtcars sinon dans la liste listeb etc... Si il ne trouve rien il affiche une erreur.
Pour attacher un fichier, une liste... , il suffit d’utiliser > attach(maliste,pos=3) (attachement en 3ème position).
Quand on exécute une fonction, R crée 1 nouveau frame qui est un environnement local dans lequel sont crées toutes les nouvelles variables ou fonctions de la fonction. Ce frame est éliminé à la sortie de la fonction ce qui explique que l’on ne retrouve jamais les variables locales d’une fonction. Les frames se superposent au dessus du frame global (là où les assignements sont permanents et gardés dans le fichier de la session courante). Dès que R ne trouve pas la fonction ou la variable, il redescend d’un frame et recherche jusqu’à arriver au frame global. Si il ne trouve rien il affiche une erreur. On peut quand même dans une fonction assigner des objets dans un autre frame inférieur par la fonction assign().
21
Librairies de programmes (packages)
Des programmes supplémentaires sont disponibles sous forme de librairies (ou packages). Pour consulter ceux disponible sur votre machine
> library()
Pour appeller (ou utiliser) un programme d’une librairie (par exemple la librairie MASS) il faut au préalable la charger dans la session par
library(MASS)
et ensuite toutes les fonctions de cette librairie sont accessibles.
Pour installer un package disponible sur CRAN, il suffit d’aller sur la page de CRAN (http://cran. univ-lyon1.fr/ ou http://cran.cict.fr/), de cliquer (à gauche) sur Packages, de choisir son pa-ckage (cliquer) et de le télécharger en version windows binary (sous windows) ou papa-ckage source (sous Linux/Unix). Pour windows dans le menu Packages, un sous menu permet d’installer le package (Install package(s) from local zip file) ; sous Linux/Unix dans une fenêtre de commande, com-piler et installer le package avec R CMD INSTALL monpackage_1.0.1.tar.gz, avec les droits “root” (ou consulter l’aide).
22
Rien ne marche ?
◦ consulter l’aide des fonctions utilisées ou l’aide générale > help(lm) aide sur la fonction lm
> help.start() aide html plus conviviale
◦ c’est bloqué : Control-C ou icone “stop” (sous windows) ◦ il y a une erreur dans ma boucle ou ma fonction : debuggage
Utiliser la fonction > browser() : >res <- NULL >x<-1:10 >for (i in 1:100) { > y<-2*x+rnorm(10,sd=10/i) > browser() > res[i]<-coef(lm(y~x)) }
l’execution s’arrete au niveau du browser (fureteur). L’ecran affiche Browse[1]>
Entrer des commandes comme
Browse[1]> i;x;y affiche i, x, et y (ils existent)
Browse[1]> coef(lm(y~x)) calcul des coefficients de la regression de y sur x (cela marche). Pour sortir du browser, tapez Q (majuscule), pour continuer l’execution tapez c. Voir aussi debug...
