Upload
others
View
4
Download
0
Embed Size (px)
Citation preview
TP d’initiation à R
Nicolas Sutton-Charani
TABLE DES MATIERES
I. Généralités ............................................................................................................................. 2
II. Calcul vectoriel ........................................................................................................................ 6
III. Calcul matriciel ........................................................................................................................ 9
I. Apprentissage automatique................................................................................................... 11
1) Regression ......................................................................................................................... 11
2) Classification ..................................................................................................................... 11
II. Import de données ................................................................................................................ 11
3) Chemin .............................................................................................................................. 11
4) Import de fichiers csv ou txt ............................................................................................... 11
5) Tableaux de données (data frame) ..................................................................................... 12
III. Visualisation ......................................................................................................................... 12
1) Graphiques simples : plot ................................................................................................... 12
2) Graphiques évolués : ggplot............................................................................................... 13
3) Interface : shiny ................................................................................................................. 13
IV. Mise en pratique ................................................................................................................... 14
Page 2 sur 14
I. Généralités
1) Démarrer R (depuis la console): On lance le logiciel R en cliquent sur l’icône R. Le symbole > signifie
que R est prêt à travailler. Il ne faut pas taper ce symbole au clavier car il est déjà présent en début
de ligne sur R console. C’est à la suite de ce symbole > que vous pourrez taper les commandes R.
Une fois la commande tapée, vous devez la valider par la touche « Entrée ».
2) Quitter R : Pour quitter R (ou R-studio), vous utilisez la commande
> q()
La question Save workspace image ? [y/n] est posée : R propose de sauvegarder le travail effectué.
Deux réponses sont possibles : y (pour yes) ou n (pour no). Si vous tapez y, cela permet que les
commandes tapées pendant la session soient conservées en mémoire et soient donc rappelables (mais
on ne peut pas les imprimer).
3) Sauvegarder sous R : Si vous quittez R en choisissant la sauvegarde de l’espace de travail, deux
fichiers sont créés :
i. le fichier R.data, qui contient des informations sur les variables utilisées
ii. le fichier R.history, qui contient l’ensemble des commandes utilisées.
4) Travailler avec R : Par exemple, tapez la commande suivante et validez :
> 2 + 5
Le résultat s’affiche sous la forme :
[1] 7
Le chiffre 1 entre crochets indique l’indice du premier élément de la ligne, le second chiffre est le
résultat de l’opération demandée.
5) Consulter l’aide de R : Pour toutes les commandes, vous pouvez consulter une fiche de
documentation en tapant, par exemple, pour la commande read.table :
> ?read.table
Faire défiler le texte avec la touche « Entrée » ou « Flèche vers le bas ». Une fois arrivé à END,
taper q. Grâce à cette aide, il suffit de retenir le nom de la commande, mais pas toute la syntaxe.
Vous pouvez rappeler les commandes déjà exécutées (pendant cette séance) en utilisant la touche «
Flèche vers le haut ».
6) Rentrer des données sous R
Différentes commandes sont disponibles pour saisir des données sous R.
a) Affectation
Un objet peut être créé avec l’opérateur « assigner » ou « affecter » qui s’écrit <- :
> n <- 15
Page 3 sur 14
> N <- 12
Pour vérifier le contenu d’un objet, taper son nom, par exemple pour n :
> n
[1] 15
Remarques
R différencie les lettres minuscules et les lettres majuscules.
En fait, le signe = convient également pour faire des affectations. Essayez :
> a = 3
> a
[1] 3
b) Suites, séquences
Exemple : si vous souhaitez créer la suite d’entiers de 1 à 12, on peut procéder de la sorte :
> suite <- 1 : 12
> suite
[1] 1 2 3 4 5 6 7 8 9 10 11 12
On peut également utiliser la fonction seq, qui crée une suite (séquence) de nombres et possède trois
arguments : from, to et by :
> seq(from = 1, to = 12, by = 1)
[1] 1 2 3 4 5 6 7 8 9 10 11 12
On peut également écrire plus simplement :
> seq(1, 12, 1)
[1] 1 2 3 4 5 6 7 8 9 10 11 12
Exemple : vous souhaitez créer un vecteur formé par les éléments d’une suite arithmétique de premier
terme 20, de dernier terme 40 et de raison 5, vous pouvez encore utiliser la fonction seq :
> seq(from = 20, to = 40, by = 5)
[1] 20 25 30 35 40
c) Simulation de données
De nombreuses lois de probabilités sont implémentées sur R et permettent des simulations variées:
Loi uniforme : runif(n, min = 0, max = 1)
Loi normale : rnorm(n, mean = 0, sd = 1)
Loi exponentielle : rexp(n, rate = 1)
Page 4 sur 14
d) Combinaison ou vecteur
Il est possible de saisir une série de valeurs numériques, caractères ou logiques.
Exemple :
> serie1 <- c(1.2, 36, 5.33, -26.5)
serie1 est un vecteur numérique. Comment le savoir ?
Tapez la commande class ou mode sur le nom de votre vecteur. Nous reviendrons sur mode au paragraphe
suivant.
> serie1
[1] 1.20 36.00 5.33 -26.50
Que remarquez-vous ?
Exemple :
> serie2 <- c("bleu", "vert", "marron")
serie2 est un vecteur de chaînes de caractères.
> serie2
[1] "bleu" "vert" "marron"
Remarque : si un vecteur est composé de caractères et de nombres, le vecteur sera un vecteur de chaînes
de caractères. Quand les composantes du vecteur sont des chaînes de caractères, il est obligatoire de les
déclarer entre guillemets, sinon R ne reconnaît pas les composantes du vecteur :
> serie2 <- c(bleu, vert, marron)
Error : Object "bleu" not found
Exemple :
> serie3 <- c(T, T, F, F, T)
serie3 est un vecteur logique.
> serie3
[1] TRUE TRUE FALSE FALSE TRUE
Exemple : lors d’une étude statistique, il peut arriver que certaines données ne soient pas disponibles : la
donnée est dite manquante. Pour saisir une donnée manquante, il est conseillé d’utiliser le symbole NA
(Not Available), quelle que soit la nature de l’objet : numérique, caractère ou logique :
> serie4 <- c(1.2, 36, NA, -26.5)
La troisième valeur est manquante.
Page 5 sur 14
> serie4
[1] 1.20 36.00 NA -26.50
e) Mode et longueur
Les objets sont caractérisés par deux attributs : le mode et la longueur.
Le mode est le type des éléments d’un objet. Comme nous venons de le voir, un objet peut être
une valeur numérique, une chaîne de caractères ou une valeur logique.
La longueur est le nombre d’éléments de l’objet.
Par exemple, si vous saisissez une série d’observations obtenues sur un échantillon sous la forme d’un
vecteur, la longueur de ce vecteur correspondra à la taille de l’échantillon. Pour connaître le mode et la
longueur d’un objet, vous utiliserez les fonctions mode et length :
> mode(serie1)
[1] "numeric"
> mode(serie2)
[1] "character"
> mode(serie3)
[1] "logical"
> length(serie1)
[1] 4
> length(serie2)
[1] 3
> length(serie3)
[1] 5
f) Saisie au clavier d’un jeu de données
En utilisant la fonction scan(), la saisie d’une série de données peut paraître moins fastidieuse.
> jeu1 <- scan()
R vous redonne la main et vous pouvez taper les valeurs du jeu de données :
1 : 1.2
2 : 36
3 : 5.33
4 : -26.5
5 : le premier retour-chariot après une chaîne vide met fin à la saisie.
Page 6 sur 14
> jeu1
[1] 1.20 36.00 5.33 -26.50
g) Éléments d’un vecteur
Il est possible de demander l’affichage d’un (ou de plusieurs) élément(s) d’un vecteur en spécifiant entre
crochets, en plus du nom du vecteur, l’indice de l’élément du vecteur. Par exemple, pour afficher
respectivement le troisième élément de serie1 et ses troisième et quatrième éléments, on utilisera :
> serie1[3]
[1] 5.33
> serie1[3 :4]
[1] 5.33 -26.50
II. Calcul vectoriel
Plusieurs opérations sont possibles sur les vecteurs : concaténation, extraction, calculs, répétition, légende
et tri.
a) Concaténer deux vecteurs
Il est possible de concaténer deux vecteurs (formés de variables de même type) pour en former un
nouveau :
> x <- c(2.3, 3.5, 6, 14, 12)
> y <- c(3.2, 5, 0.7, 1, 3.5)
> z <- c(x, y)
> z
[1] 2.3 3.5 6.0 14.0 12.0 3.2 5.0 0.7 1.0 3.5
b) Extraire des données d’un vecteur
Il est possible d’extraire des données d’un vecteur.
Utiliser un vecteur pour préciser le numéro d’ordre des composantes à extraire. Ainsi, pour
extraire les 2ème et 5ème composantes du vecteur x :
> x[c(2, 5)]
[1] 3.5 12.0
L’utilisation du signe « tiret »permet de supprimer des composantes, par exemple pour supprimer
les 2ème et 3ème composantes du vecteur x :
> x[-c(2, 3)]
Page 7 sur 14
[1] 2.3 14.0 12.0
Utiliser un vecteur formé de valeurs logiques. Par exemple, pour obtenir un vecteur ne contenant
que les composantes supérieures à 4, vous pouvez utiliser la commande :
> x[x > 4]
[1] 6 14 12
Si vous disposez de deux vecteurs ayant le même nombre de composantes, vous pouvez demander à
afficher les valeurs de l’un pour lesquelles les valeurs de l’autre sont supérieures (ou inférieures) à une
certaine valeur. Par exemple, les vecteurs x et y sont composés de 5 valeurs. Vous pouvez demander à
extraire de y les valeurs de y pour lesquelles x est supérieur à 4 en utilisant la ligne de commandes
suivante :
> y[x > 4]
[1] 0.7 1.0 3.5
c) Faire des calculs sur les composantes d’un vecteur
R peut faire des calculs sur l’ensemble des composantes d’un vecteur :
> 20 + x * 5
[1] 31.5 37.5 50.0 90.0 80.0
> (x + y) / 2
[1] 17.125 20.875 28.250 51.000 46.375
d) Remplacer des données dans un vecteur
Il est possible de remplacer certaines composantes d’un vecteur par de nouvelles valeurs.
Considérons une suite de valeurs numériques :
> x <- 1 : 10
Exemple 4.1 Si vous voulez remplacer le 3ème valeur de x par 35, vous utiliserez la ligne de commandes
suivante :
> x[3] <- 35
puis vous demanderez à R d’afficher le résultat
> x
[1] 1 2 35 4 5 6 7 8 9 10
Exemple : si vous voulez remplacer la valeur 1 par la valeur 25, vous utiliserez alors la ligne de commandes
suivante :
> x[x == 1] <- 25
puis vous demanderez à R d’afficher le résultat
Page 8 sur 14
> x
[1] 25 2 35 4 5 6 7 8 9 10
Exemple : si vous voulez remplacer toutes les valeurs supérieures ou égales à 5 par 20, vous utiliserez la
ligne de commandes suivante :
> x[x >= 5] <- 20
puis vous demanderez à R d’afficher le résultat
> x
[1] 20 2 20 4 20 20 20 20 20 20
e) Répéter les données d’un vecteur
La fonction ‘rep’ admet deux arguments x et times et crée un vecteur où x est répété times fois.
Exemple : vous créez une variable ‘donnees’ par :
> donnees <- c(1, 2, 3)
Si vous voulez qu’un nouveau vecteur contienne deux fois le vecteur donnees, alors vous écrirez :
> rep(x = donnees, times = 2)
Exemple : vous pouvez également demander qu’un vecteur contienne 50 fois la valeur 1 :
> rep(1, 50)
Exemple 4.6 ou 4 fois la chaîne de caractères "chien" :
> rep("chien", 4)
f) Nommer les composantes d’un vecteur
Il est possible de donner un nom à chaque composante d’un vecteur.
Exemple : le vecteur ‘notes.Jean’ contient les notes obtenues par Jean en anglais, informatique et biologie.
Première façon : vous pouvez utiliser la commande :
> notes.Jean <- c(anglais = 12, informatique = 19.5, biologie = 14)
Affichez ensuite le vecteur notes.Jean, on obtient le résultat suivant :
anglais informatique biologie
12.0 19.5 14.0
Seconde façon : on peut nommer les composantes d’un vecteur en définissant un vecteur formé
de chaînes de caractères puis en utilisant le fonction names :
> matiere <- c("anglais", "informatique", "biologie")
> matiere
Page 9 sur 14
> note <- c(12, 19.5, 14)
> names(note) <- matiere
> note
anglais informatique biologie
12.0 19.5 14.0
Remarque : Pour supprimer les noms, on tapera la ligne de commandes :
> names(note) <- NULL
g) Trier les composantes d’un vecteur
Vous pouvez trier les composantes d’un vecteur par ordre croissant en utilisant la fonction ‘sort’.
> sort(note)
[1] 12.0 14.0 19.5
ou dans l’ordre décroissant :
> rev(sort(note))
[1] 19.5 14.0 12.0
III. Calcul matriciel
Comme les vecteurs, les matrices sont de mode quelconque mais ne contiennent que des éléments de
même nature. Pour créer une matrice, on utilise la commande ‘matrix(vec, nrow = n, ncol = p)’ où ‘vec’ est
le vecteur contenant les éléments de la matrice de taille n par p, qui seront rangés en colonne sauf si
l’option ‘byrow = T’ est utilisée.
> A = matrix(1 : 15, ncol = 5)
> A
> B = matrix(1 : 15, nc = 5, byrow = T)
a) Éléments d’une matrice
> A[1, 3]
> A[, 2]
> B[2, ]
> A[2 : 3, 2 : 4]
> B2 = B
> B2[1, 1] = "toto"
Page 10 sur 14
> B2
b) Concaténations
> cbind(A, B)
> rbind(A, B)
c) Opérations terme à terme 144.96 140.12
> g = seq(0, 1, length=20)
> C = matrix(g, nrow=4)
> dim(C)
> C[C[, 1] > 0.1, ]
> D = matrix(runif(16), ncol = 4) # tirage aléatoire uniforme
> D > 0.5
> D[D[, 1] > 0.5, 2]
> A + B
> A * B
> cos(A)
> cos(A[1 : 2, 1 : 2])
d) Inversion
> solve(A)
> solve(A[1 : 2, 1 : 2])
e) Produit matriciel
> t(A) %*% B
> A[1 : 2, 1 : 2] %*% B[1 : 2, 1 : 3]
> t(B)
f) Diagonalisation
> diag(A)
> apply(A, 2, sum)
> apply(D, 1, max)
> s = eigen(A[1 : 2, 2 : 3]) # éléments propres
> s$values
> s$vectors
Page 11 sur 14
I. Apprentissage automatique
1) Regression
> dat <- iris
> head(dat)
> names(dat)
> mod <- lm(Sepal.Length ~ Sepal.Width + Petal.Length + Petal.Width, dat)
> summary(mod)
2) Classification
> library(rpart)
> library(rpart.plot)
> mod <- rpart(Species ~ ., dat, method = "class")
> prp(mod)
> pred <- predict(mod, dat, type = "class")
> sum(pred == dat$Species)/nrow(dat)
II. Import de données
3) Chemin
Pour connaître le répertoire courant :
> getwd()
Pour connaître lesichiers présents dans l'environnement de travail :
> ls()
Pour changer le répertoire courant :
> setwd("C:/Documents/Rproject") # Attention remplacer les ‘\’ par des ‘/’
4) Import de fichiers csv ou txt
Page 12 sur 14
> read.table("fileName.csv")
Il faut souvent changer les paramètres d’import :
> read.table("fileName.txt", sep = ",", dec = ".", strinagsAsFactors = False)
5) Tableaux de données (data frame)
Liste = collection ordonnée d’objets qui peuvent être de classes différentes
> l <- list(nom = c("bob", "julie", "tom", "mégane"), age = 1 : 10)
> l
> l$age
> l$nom[4]
Data frame = liste pour laquelle chaque composante a le même nombre d’éléments
= matrice où les colonne sont nommées et de types mixtes (-> calcul matriciel possible)
> df <- data.frame(nom = c("bob", "julie", "tom", "mégane"), age = 1 : 4)
> df
III. Visualisation
1) Graphiques simples : plot
> x <- seq(from = -5, to = +5, by = 0.01)
> y <- cos(x)
> plot(x, y)
ou si on travaille avec un dataframe (df <- data.frame(x, y)) :
> plot(df)
Personnalisation :
> plot(df, main = "Graphique simple", col = "green", type = "l", ylab = "cosinus")
Page 13 sur 14
2) Graphiques évolués : ggplot
> library(ggplot2)
> ggplot(df, aes(x, y))+ geom_point()
Exemple plus complet: créer un dossier ‘data’ dans le répertoire courant puis
> file <- "data/debt.csv"
> download.file("http://www.stat.cmu.edu/~cshalizi/uADA/13/hw/11/debt.csv", file, mode = "wb")
> debt <- read_csv(file)
> summary(debt)
> head(debt)
> qplot(data = debt, y = growth, x = Year, geom = "line") +
facet_wrap(~ Country)
> ggplot(data = debt, aes(x = ratio > 90, y = growth)) +
geom_boxplot()
3) Interface : shiny
La package shiny de R permet la réalisation d’application (web), très utiles pour visualiser des données de
manière interactive. Savoir développer des applications R-shiny représente actuellement une compétence
précieuse car elle permet la valorisation de votre travail et favorise grandement la collaboration avec des
gens ne maitrisant pas forcément la science des données ou/et R.
Une application shiny est constituée (à minima) de 2 scripts généralement nommés 'ui.R' et 'serveur.R'. Le
premier contient l’architecture de la page (boutons, etc), le second contient le code qui doit s’exécuter
derrière en fonction du comportement (i.e. des clicks) de l’utilisateur.
Avec votre compte R-studio (gratuit), vous pouvez héberger gratuitement 5 applications shiny sur le
serveur de R-studio. Il faut cependant noter qu’en tout vous avez un temps de connexion limité à vos
applications (environ 50h par mois).
Pour publier votre application R-shiny, il suffit de la lancer sur R-studio puis de cliquer sur le bouton
'Publish' en haut à droite de l’écran.
Un premier exemple très simple d’application shiny est disponible à l’adresse suivante :
https://drive.google.com/open?id=1A_npXeakRmeKhxpzGT8lE3a59zNDWXmg.
Après vous être familiarisé avec ce premier exemple, vous pouvez accéder à cet autre exemple constitué
d’une application shiny d’analyse de données sommaire :
https://drive.google.com/open?id=104gtOr4k_GWrCpEUO6edAIY8Q7LEzF4G.
Page 14 sur 14
IV. Mise en pratique
Téléchargez le jeu de données ‘gobelins’ à l’adresse suivante :
https://www.dropbox.com/s/pn468bvrpliq7fm/gobelins.csv?dl=0.
1) Calculez la longueur moyenne des os des monstres de type "Ghoul".
2) Représentez graphiquement les distributions de chaque variable pour chaque monstre.
3) Construisez un arbre de décision prédisant le type de monstre, représentez-le graphiquement et
évaluez-le.
4) Développez une application shiny permettant la visualisation de cet arbre en proposant à
l’utilisateur de régler manuellement et de façon interactive la complexité de l’arbre (paramètre
‘cp’ de la fonction rpart).
5) Publiez l’application sur le serveur de r-studio après personnalisation.