Initiation à R

L'objectif est de vous familiariser avec R, un environnement libre pour le calcul statistique.

Lancer R et le quitter

Lancer R

Ouvrez une fenêtre shell, tapez la commande R et voilà... vous obtenez ce qui suit :

Les commandes essentielles sont indiquées dans ce message, en particulier comment quitter R. La dernière ligne qui commence par un > est une invite pour que vous tapiez une commande : c'est ce que l'on appelle un « prompt », c'est-à-dire, un signe qui vous indique que le logiciel attend que tapiez quelque chose.

Quitter R

La dernière ligne du message d'accueil vous informe que pour quitter R, il faut taper la commande q() suivie d'un retour-chariot (= touche Entrée). Faites-le ; vous obtenez le résultat suivant :

Vous avez là la possibilité de sauvegarder votre travail en tapant y (comme 'y'es) suivi d'un retour-chariot, ou de quitter R sans sauvegarder votre travail en tapant n (comme 'n'o), ou encore de revenir dans R en tapant c (comme 'c'ontinue).
Si vous quitter R en sauvegardant votre travail, vous avez aussi la possibilité de récupérer votre travail et de le mettre soit sur votre clé USB, soit vous l'envoyer par email pour travailler chez vous (par exemple). Cela sera expliqué à la fin du TP.

Pour l'heure, le TP ne fait que commencer, donc restez sous R en tapant c (suivi de retour-chariot : il faut toujours taper un retour-chariot après une commande pour la valider et que R la prenne en compte ; on ne le dira donc plus).

R : une calculatrice

Calculs élémentaires

L'utilisation la plus simple de R est de l'utiliser comme une « simple » calculatrice. On verra que c'est en fait une calculatrice très sophistiquée.

Par exemple, tapez la commande suivante (tous les exemples doivent être tapés ; le symbole > indique qu'il s'agît d'une commande R : vous ne devez pas le taper, il est déjà affiché à l'écran) :

> 2+3

R vous répond immédiatement :

[1] 5

Si on laisse de côté le [1] qui sera expliqué plus loin, on obtient bien le résultat attendu.

Naturellement, tous les opérateurs habituels sont disponibles, ainsi que les fonctions logarithmiques, trigonométriques, et bien d'autres.

On peut affecter le résultat d'un calcul à une variable. Une variable est une entité qui porte un nom et qui contient une valeur. Par exemple, si on tape :

> a <- 2 * sqrt (5) + pi

R n'affiche rien, mais il a :

calculé la valeur de l'expression 2 * sqrt (5) + pi ;
affecté cette valeur à une variable dont le nom est a.

L'affectation se fait donc par l'opérateur <-. À sa gauche, on indique le nom de la variable à laquelle il faut affecter la valeur qui se trouve à sa droite. En passant, vous aurez noter l'utilisation de pi pour obtenir la valeur de π. pi est une variable pré-définie dans R dont la valeur est celle de π.

On peut afficher la valeur d'une variable en tapant simplement son nom :

a
[1] 7.613729

Naturellement, on peut utiliser la valeur d'une variable pour effectuer des calculs, par exemple :

> b <- (a - 1) * (a + 1)

Pour simplifier la saisie des commandes, vous pouvez utiliser la touche flêchée ↑ pour retrouvez les commandes que vous avez déjà tapées et pour les modifier. Ainsi, R garde l'historique des commandes que vous tapez. Vous pouvez remonter dans l'historique avec la touche ↑ et redescendre avec la touche ↓. Quand vous remontez dans l'historique, vous pouvez ensuite utiliser les touches flêchées ← et → pour éditer la commande. Ainsi, utilisez ces touches pour taper la commande suivante, qui diffère peu d'une commande que vous avez tapée plus haut :

> 3 * sqrt (5 + pi)

Prenez l'habitude d'utiliser ces touches flêchées : elles permettent d'accélérer très sensiblement la saisie des commandes, et ceci, même si l'on est déjà habile avec le clavier de son ordinateur.

La table suivante indique des opérateurs et des fonctions de R :

notation en R	valeur mathématique
`a + b`	somme de a et b
`a - b`	b soustrait de a
`a * b`	produit de a par b
`a / b`	division réelle de a par b
`a %/% b`	division euclidienne (entière) de a par b
`a %% b`	a mod b
`a ^ b`	a à la puissance b
`sqrt (a)`	racine carrée de a
`abs (a)`	valeur absolue de a
`log (a)`	logarithme naturel de de a
`exp (a)`	exponentielle de a
`sin (a)`	sinus de a (en radians)
`cos (a)`	cosinus de a (en radians)
`tan (a)`	tangente de a (en radians)

Cette liste est loin d'être exhaustive !

calculez les racines de l'équation 2 x² + 5 x - 12 = 0.

À tout moment une aide en ligne est accessible avec la commande ?topic, où topic peut être remplacé par n'importe-quelle commande. Essayez, par exemple ?log. (Tapez 'q' pour quitter l'aide.) Il est très important d'apprendre à lire l'aide. L'aide en-ligne contient énormément d'information : elle est là, disponible, c'est à vous d'apprendre à l'utiliser. Les pages d'aide ont toutes la même structure :

une description rapide de la commande et, éventuellement, de commandes apparentées. Pour log, diverse commandes calculant le logarithme dans différentes bases et les exponentiations sont apparentées ;
comment on utilise la commande ;
les paramètres de la commande ;
une description détaillée de la commande ;
la valeur de la commande. Là, le comportement de la fonction dans des cas exceptionnels est indiqué ; ainsi, on apprend que log(0) a pour valeur -Inf, c'est-à-dire moins l'infini ;
des remarques complémentaires ;
des références bibliographiques où la manière dont la fonction est calculée est tirée ;
d'autres commandes à consulter si l'on veut des informations complémentaires, sur d'autres fonctions proches ;
des exemples : cette section est extrêmement utile car si l'on n'a pas compris les explications, on nous donne des exemples d'utilisation qui peuvent être directement copiées/collées dans R.

Calculs avec des complexes

Jusqu'à maintenant, on n'a manipulé que des nombres réels. On peut aussi manipuler des nombres complexes directement : si l'on colle un i juste derrière un réel, il devient un nombre imaginaire. Ainsi, 2+3i est un nombre complexe, dont la partie réelle vaut 2, la partie imaginaire vaut 3. (Attention, le i doit être collé au nombre.)

soustraire 4-1.5i de 2+3i.
résoudre 2 x² + 5 x + 12 = 0.
afficher la valeur de la racine carrée de -1 (en utilisant la fonction sqrt. (si vous avez du mal, lisez la phrase qui suit.)

Pour savoir si R fait ses calculs dans les réels ou les complexes, la règle est la suivante : si vous n'utilisez que des nombres réels, R fait les calculs dans l'ensemble des réels. Si un complexe intervient, R fait ses calculs dans les complexes. Ainsi, on peut utiliser la notation 0i qui d'un point de vue mathématique n'a pas beaucoup d'intérêt, pour obliger R à faire ses calculs avec des complexes.

Il existe des fonctions pré-définies spécifiques pour les complexes (partie réelle, partie imaginaire, module, argument, conjugué). Vous taperez ?complex pour en avoir une liste. Par ailleurs, toutes les fonctions réelles vues plus haut sont étendues aux complexes.

Vecteurs

Après les simples nombres, un deuxième type fondamental d'entités dans R est le vecteur. Un vecteur peut-être créé de différentes manières. Par exemple, créons un vecteur dont les éléments sont 0, -1, π et 4,78, et mettons-le dans une variable dont le nom est v :

> v <- c (0, -1, pi, 4.78)

La fonction c assemble et construit un vecteur avec ces valeurs. On peut ensuite consulter la valeur des composantes du vecteur :

> v
[1]  0.000000 -1.000000  3.141593  4.780000

On retrouve bien les valeurs avec lesquelles on a initialisé le vecteur.

De nombreuses fonctions s'appliquent aux vecteurs. La table ci-dessous en contient un certain nombre ; essayez-les toutes :

notation en R	valeur	résultat sur l'exemple
`length (v)`	nombre d'éléments de `v`	`4`
`min (v)`	valeur de l'élément minimal de `v`	`-1`
`max (v)`	valeur de l'élément maximal de `v`	`4.78`
`range (v)`	vecteur composé des deux valeurs précédentes (le min et le max de `v`)	`-1.00 4.78`
`sum (v)`	valeur de la somme des éléments de `v` : Σ_iv_i	`6.921593`
`prod (v)`	valeur du produit des éléments de `v` : Π_iv_i	`0`
`which.min (v)`	indice de l'élément minimal de `v` (arg min_i v_i)	`2`
`which.max (v)`	indice de l'élément maximal de `v` (arg max_i v_i)	`4`

Opérations mathématiques sur les vecteurs

R peut naturellement effectuer toutes les opérations habituelles sur les vecteurs. Les opérateurs vues plus haut sur les nombres (+, -, ...) et les fonctions (abs, log, ...) s'appliquent sur les vecteurs comme on s'y attend. Toutes ces opérations se font terme à terme : aussi, quand il y a deux vecteurs (comme pour une addition), il faut que les deux vecteurs aient le même nombre d'éléments.

Une opération très classique est de calculer le produit scalaire de deux vecteurs :

définissez un vecteur dénommé w et initialisez ses composantes avec 3, -78, 0, 2;
essayez v %*% w et concluez vous-même.

Enfin, on peut ajouter un scalaire aux éléments d'un vecteur, la soustraire, la multiplier, ... par les opérateurs habituels (+, -, *, ...) en combinant un vecteur et un scalaire. Ainsi,

v + 3

produit un vecteur dont les composantes sont celles de v augmentées de 3.

Indexation des éléments d'un vecteur

On peut aussi demander la valeur du troisième élément du vecteur à l'aide de l'opérateur [ :

v [3]
[1] 3.141593

On peut aussi demander la valeur des éléments 1 et 3 du vecteur en fournissant plusieurs indices, comme suit :

v [c (1, 3)]
[1] 0.000000 3.141593

On voit que pour cela, on a spécifié un vecteur dont les composantes sont les indices qui nous intéressent (c (1, 3) est un vecteur de deux éléments, le premier vaut 1, le second vaut 3).

On vient donc de présenter une opération très utile et très importante en R : accéder aux élements d'un vecteur en utilisant un autre vecteur (dénommé « vecteur d'index ») qui contient le numéro des composantes que l'on veut sélectionner.

Une autre manière de spécifier les indices qui nous intéressent est la suivante : 2:4 est un vecteur dont les éléments sont 2, 3 et 4.

Une autre notation pour la même chose consiste à utiliser la fonction seq(). Ainsi,

> seq (2, 4)

(ou

> seq (from = 2, to = 4)

) produit un vecteur dont les éléments sont 2, 3 et 4.
L'intérêt de cette fonction seq()uence et que l'on peut lui indiquer plus généralement la valeur du premier indice, du dernier indice et de l'incrément pour passer de l'un à l'autre. Ainsi :

> seq (from = 1, to = 10, by = 2)
[1] 1 3 5 7 9

l'incrément peut aussi être négatif :

> seq (from = 10, to = -5, by = -2)
[1] 10  8  6  4  2  0 -2 -4

Quelques fonctions statistiques sur les vecteurs

En statistique et fouille de données, un vecteur va typiquement contenir des données sur lesquelles on voudra effectuer des traitements statistiques. Les plus simples sont résumés dans la table ci-dessous :

notation en R	valeur	résultat sur l'exemple
`mean (v)`	la moyenne des éléments de `v`	`1.730398`
`var (v)`	la variance des éléments de `v`	`7.246964`
`sd (v)`	l'écart-type des éléments de `v`	`2.692019`
`summary (v)`	fournit plusieurs statistiques sur les éléments de `v`	`Min. 1st Qu. Median Mean 3rd Qu. Max.` `-1.000 -0.250 1.571 1.730 3.551 4.780`

Indexation par un vecteur de booléens

Outre les nombres, R manipule des booléens, qui prennent soit la valeur TRUE (que l'on peut abréger en T), soit la valeur FALSE (que l'on peut abréger en F).
Les booléens apparaissent typiquement à l'occasion du test de la valeur d'une variable : est-elle égale à une autre valeur, plus petite, plus grande, ... La table ci-dessous indique ces opérateurs :

notation en R	valeur	résultat sur l'exemple
`a == 1`	teste l'égalité entre deux valeurs	`FALSE`
`a != 1`	teste la différence entre deux valeurs	`TRUE`
`a < 1`	c'est clair, non !	`FALSE`
`a <= 1`	ça aussi	`FALSE`
`a > 1`	ça aussi	`TRUE`
`a >= 1`	ça aussi	`TRUE`

Bien sûr, on peut comparer la valeur de deux variables (donc, écrire a == b qui donne FALSE ici).
De la même manière, on peut effectuer ces opérations sur les éléments d'un vecteur. Ainsi,

> v < w
[1]  TRUE FALSE FALSE FALSE

Tout comme plus haut on a sélectionné les éléments d'un vecteur avec un vecteur d'indices, on peut sélectionner les éléments d'un vecteur avec un vecteur de booléens. Ainsi, si l'on veut affecter à 100 les éléments de v qui sont plus petits que ceux de w, on pourra écrire :

> v [v < w] <- 100

Cette opération ne modifiera que le premier élément de v, qui correspond à la seule valeur TRUE du vecteur de booléens utilisé pour l'indexer.

La fonction runif() génère des nombres pseudo-aléatoires depuis une distribution de probabilité uniforme. On va l'utiliser pour générer des vecteurs aussi grands que l'on veut. Ainsi, tapez :

> vu <- runif (100)

et la variable vu contient un vecteur de 100 composantes dont la valeur a été tirée au hasard entre 0 et 1.

quelle est la somme des composantes du vecteur vu ?
quelle est la somme des composantes du vecteur vu dont la valeur est > 0,5 ?
combien le vecteur vu a-t-il de composantes dont la valeur est > 0,5 ?
quelle commande tapez-vous pour calculer la somme des éléments d'indice pair de vu ?
on veut obtenir le vecteur vs ayant 50 composantes, dont la valeur de la composante i est la somme des composantes 2*i-1 et 2*i de vu. Comment faites-vous ?

Quelques détails de plus sur les booléens

Il existe des opérations sur les booléens, celles de l'algèbre de Boole : ET, OU, NON, ... On suppose que l'on a défini deux vecteurs booléens comme suit :

> bool1 <- c (T, T, F)
> bool2 <- c (F, T, F)

On résume les principales opérations logiques dans la table ci-dessous :

notation en R	valeur	résultat sur l'exemple
`bool1 & bool2`	ET logique	`FALSE TRUE FALSE`
`bool1 \| bool2`	OU logique	`TRUE TRUE FALSE`
`! bool1`	négation	`FALSE FALSE TRUE`

combien le vecteur vu a-t-il de composantes dont la valeur est comprise entre 0,25 et 0,75 ?

Étude d'un jeu de données

Le TP va maintenant s'organiser autour de l'exploration d'un jeu de données concernant le sommeil d'un ensemble de mammifères.

le jeu de données sleep au format open office (ods) [aussi au format xl et au format texte/csv]. Explication des attributs :
- espèce animale
- poids du corps en kg
- poids du cerveau en g
- durée moyenne de sommeil non paradoxal (h/j)
- durée moyenne de sommeil paradoxal (h/j)
- durée moyenne de sommeil (h/j) : c'est la somme des deux attributs précédents
- durée maximale de vie (ans)
- durée de gestation (j)
- indice de prédation : 1 = minimum (le moins sujet à la prédation) ; 5 = maximum (le plus sujet à la prédation)
- indice d'exposition durant le sommeil : 1 = le moins exposé ; 5 = le plus exposé
- indice de danger : 1 = minimum (le moins en danger vis à vis des autres animaux) ; 5 = maximum
(ces données proviennent de l'article "Sleep in Mammals: Ecological and Constitutional Correlates" by Allison, T. and Cicchetti, D. (1976), Science, November 12, vol. 194, pp. 732-734.)

Charger le jeu de données dans R

Un jeu de données se met dans un data frame dans R~: c'est un tableau dans lequel chaque ligne contient une donnée (un individu) et chaque colonne un attribut (une observation).

Pour le charger depuis un fichier au format csv dans R dans un objet dénommé sommeil, on tapera~:

> sommeil <- read.csv ("http://www.grappa.univ-lille3.fr/~ppreux/ensg/ed/R/sleep.csv", dec=",", sep="")

Premier contact avec ce jeu de données

taper le nom du data frame affiche son contenu (ne pas le faire si le jeu de données est gros ! ici, ça va)
le nombre de données (= le nombre de lignes) est obtenu par la fonction nrow (sommeil) ;
le nombre d'attributs (= le nombre de colonnes) est obtenu par la fonction ncol (sommeil) ;
le nom des attributs est obtenu par la fonction names (sommeil) ;
des statistiques descriptives élémentaires de chacun des attributs sont obtenues par la fonction summary (sommeil) ;

Accès aux données dans un jeu de données

afficher la valeur de l'attribut Dreaming pour toutes les données
afficher la valeur de l'attribut Dreaming pour toutes les données pour lesquelles cette valeur est connue (non NA)
afficher les valeurs de l'attribut Dreaming supérieures à 1
afficher les valeurs de l'attribut Dreaming supérieures à la moyenne de cet attribut
afficher la donnée dont la durée de vie est la plus grande
afficher le nom des espèces dont la durée de vie est > 20 ans

Quelques graphiques

Faire les graphiques que l'on a vu ensemble dans la présentation.

Faire un graphe de la durée de sommeil paradoxal en fonction de la durée de sommeil où chaque point est coloré en fonction de son indice de prédation (par exemple : jaune si 1, orange si 2, rose si 3, rouge si 4, noir si 5).