Le but de ces notebooks est d’apréhender le langage R, tout d’abord en abordant les types de données R, pour ensuite continuer sur les types de structure. Plusieurs fonctions seront implémentées, notamment pour connaitre le type de données utilisé, comment installer de nouveaux packages, visualiser un tableau de données, manipuler, transformer, lire/écrire des données. Enfin, en dernière partie nous verrons comment créer des graphiques.
Pour ceux non familiarisés avec le Notebook, c’est un cahier intéractif mélangeant code, documentation au format Markdown et résultats, d’autres outils comme Jupyter le propose. Chaque cellule peut être exécutée de manière indépendante, tout en prenant en compte le contexte du Notebook. C’est un format particulièrement intéressant pour l’exploration de données et la formation.
La richesse de R n’est pas tant dans son langage, mais dans la diversité et la complétude de ses différents packages (plus de 14 000).
R et Python sont les langages couramment utilisés dans le domaine de la data science aujourd’hui. Ils sont complémentaires, Python parallelisera plus facilement ces traitements sur CPU/GPU/TPU, il sera plus facilement industrialisable, tandis que R de son côté possède des métriques statistiques plus précises pour valider des hypothèses, répondant pleinement à la rigueur qu’impose la data science.
R est un langage qui a démarré en 1993, ses bases ainsi que plusieurs de ses packages sont écrits en C, Fortran ou R, ce qui en fait un langage relativement rapide sur certains types d’opérations.
R est un langage orienté statistique, permettant de traiter et nettoyer des jeux de données afin d’y appliquer des tests statistiques, ou encore des modèles de machine learning. Il offre la possibilité de créer des graphiques rapidement, de traiter des volumes importants, qui plus est il est entièrement gratuit.
Le langage R est un langage interprété, pas d’étape de compilation, il dispose d’un typage faible, pas de déclaration des types de variables, le type de la donnée est connu après sont initialisation/affectation.
Les objectifs recherchés peuvent etre multiples, on peut rechercher à realiser de la segmentation client, du ciblage marketing, de la détection de fraude, analyser des enquêtes de satisfaction…
R Studio est l’IDE pour R, il existe en version locale ainsi qu’en version serveur, où sur ce dernier plusieurs sessions peuvent être initiées sur un même client R Studio.
La version Desktop se trouve sur ce lien.
Vous pouvez télécharger la version FREE Rstudio Desktop.
Une fois installé et ouvert, vous pouvez en haut à droite cliquer sur l’icone (en dessous de l’onglet file), et choisir R Script. De là vous pouvez commencer à coder, c’est l’encadré principal, dédié aux développements. Vous apercevrez également d’autres frames, en haut à droite se trouve un encadré pour visualiser les variables en cours d’utilisation (en mémoire) dans votre Environnement, l’historique de vos commandes, ainsi que vos Connections : bases de données, Spark, …
L’encadré en bas à droite permet via l’onglet Files de visualiser l’environnement local (généralement votre dossier Home), Plots affichera les graphiques a l’exécution du code, Packages liste les packages installés que vous pouvez charger pour utilisation. Help affichera la documentation relative aux libraires implentées, Viewer affiche des contenus HTML.
Enfin, le dernier encadré en bas à gauche vous permettra d’accéder à la Console R qui restitue les erreurs et les résultats, se trouve aussi un Terminal système, ainsi qu’un dernier onglet Jobs, afin de lancer des scripts R sans avoir à les ouvrir pour exécuter le code à la main.
Vous pouvez également vous référer au cheat sheet RStudio sur ce lien.
Vous pouvez effectuer quelques calculs directement dans la console ou en codant sur le script R ouvert.
(250/10)*2## [1] 50log(x = 1000, base = 10)## [1] 3sqrt(100)## [1] 1010^2## [1] 100exp(log(1))## [1] 1La fonction typeof() permet de récupèrer la nature de l’objet.
Les affectation de variables peuvent se faire soit via le signe “<-”, soit traditionnellement par “=”
ent <- 3
typeof(ent)## [1] "double"dec <- 3.5
typeof(dec)## [1] "double"dec <- as.integer(dec)
dec## [1] 3typeof(dec)## [1] "integer"Possibilité de convertir facilement une chaine de caractères en numérique et inversement.
a <- "Hello Word"
print(a)## [1] "Hello Word"typeof(a)## [1] "character"dec <- "4.78"
dec <- as.numeric(dec)
dec-1## [1] 3.78t = TRUE
class(t)## [1] "logical"f = FALSE
t==f## [1] FALSEElles sont souvent peu évoquées, pourtant beaucoup de modèles et d’analyses se basent sur des séries temporelles. Ce format permet de calculer des différences entre des dates, en jours, semaines…
date = "2013-02-08"
date = as.Date(date)
class(date)## [1] "Date"date2 = as.Date("2013-04-08")
date2 - date## Time difference of 59 daysdifftime(date2, date, units="weeks")## Time difference of 8.428571 weeksdate + 10## [1] "2013-02-18"Les données manquantes sont représentées par le sigle “NA” (Not Available). Ce n’est pas un réellement un type de données, mais plus un état, une valeur logique constante.
v = c(1, 2, 4, NA, 8, 16, NA)
is.na(v)## [1] FALSE FALSE FALSE TRUE FALSE FALSE TRUEmedian(v)## [1] NAmedian(v, na.rm = TRUE)## [1] 4v <- replace(v,is.na(v), 10)
median(v)## [1] 8Le paramètre na.rm supprime les NA avant exécution. La fonction replace() permet de remplacer tous les NA / valeurs nulles, par 10, ce qui affecte ici la médiane de la série.
R propose un format brut afin de pouvoir stocker des objets binaires sous forme d’octets (hexadécimales).
v = as.raw(c(3, 6, 9, 12))
v## [1] 03 06 09 0c| Type de la donnée | Type R | Exemple |
|---|---|---|
| Réel entier/décimal | numeric | 2, 2.37 |
| Chaine de caractères | character | “hello” |
| Booléen | logical | TRUE, FALSE |
| Dates | date | “2018-11-05” |
| Valeur manquante | logical | NA |
| Binaire | raw | 0c 03 |
A l’instar de la fonction typeof(), la fonction class() déterminera la structure d’un objet, R propose plusieurs organisations d’objets.
Elle représente une suite de données, toujours de même type. On peut créer un vecteur grâce à la fonction c(), déjà utilisée précédemment.
v = c("a", "b", "c")
v## [1] "a" "b" "c"Ajouter un élément
v2 = c(v, "m", "n")
v2## [1] "a" "b" "c" "m" "n"Supprimer un élément
v2 = v2[-3]
v2## [1] "a" "b" "m" "n"La matrice est une suite à mutiples indices, c’est aussi un type de tableau, où chaque colonne doit être de même type et de même longueur. L’ajout de données se fait de manière séquentielle en renseignant le paramètre byrow=TRUE, qui signifie ajout par lignes, ou byrow=FALSE pour l’ajout par colonnes.
rownames = c("row1","row2","row3","row4")
colnames = c("col1","col2","col3")
mx <- matrix(data = 1:12, nrow=4, ncol = 3, byrow = TRUE, dimnames = list(rownames, colnames))
mx## col1 col2 col3
## row1 1 2 3
## row2 4 5 6
## row3 7 8 9
## row4 10 11 12Ajouter lignes et colonnes
mx <- rbind(mx, row5=c(20, 30, 40))
mx## col1 col2 col3
## row1 1 2 3
## row2 4 5 6
## row3 7 8 9
## row4 10 11 12
## row5 20 30 40mx <- cbind(mx, col4=c(11, 21, 31, 41, 51))
mx## col1 col2 col3 col4
## row1 1 2 3 11
## row2 4 5 6 21
## row3 7 8 9 31
## row4 10 11 12 41
## row5 20 30 40 51Supprimer lignes et colonnes
mx <- mx[-2,]
mx## col1 col2 col3 col4
## row1 1 2 3 11
## row3 7 8 9 31
## row4 10 11 12 41
## row5 20 30 40 51mx <- mx[,-2]
mx## col1 col3 col4
## row1 1 3 11
## row3 7 9 31
## row4 10 12 41
## row5 20 40 51rbind pour row bind permet d’ajouter des lignes, cbind pour column bind ajoute des colonnes. Les deux dernières opération permettent de supprimer ligne ou colonne, nous verrons comment parcourir ces objets un peu plus loin.
Permet de créer des matrices à multiples dimensions
Tableau 1 colonne
arr = array(data = 1:12, dim = c(12))
arr## [1] 1 2 3 4 5 6 7 8 9 10 11 12Tableau 3 colonnes, 4 lignes
arr = array(data = 1:12, dim = c(3, 4))
arr## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 122 x 3 tableaux de 3 colonnes et 4 lignes
arr = array(data = 1:72, dim = c(3, 4, 3, 2))
arr## , , 1, 1
##
## [,1] [,2] [,3] [,4]
## [1,] 1 4 7 10
## [2,] 2 5 8 11
## [3,] 3 6 9 12
##
## , , 2, 1
##
## [,1] [,2] [,3] [,4]
## [1,] 13 16 19 22
## [2,] 14 17 20 23
## [3,] 15 18 21 24
##
## , , 3, 1
##
## [,1] [,2] [,3] [,4]
## [1,] 25 28 31 34
## [2,] 26 29 32 35
## [3,] 27 30 33 36
##
## , , 1, 2
##
## [,1] [,2] [,3] [,4]
## [1,] 37 40 43 46
## [2,] 38 41 44 47
## [3,] 39 42 45 48
##
## , , 2, 2
##
## [,1] [,2] [,3] [,4]
## [1,] 49 52 55 58
## [2,] 50 53 56 59
## [3,] 51 54 57 60
##
## , , 3, 2
##
## [,1] [,2] [,3] [,4]
## [1,] 61 64 67 70
## [2,] 62 65 68 71
## [3,] 63 66 69 72Les listes représentent des collections d’objets ordonnés, pouvant contenir tout type de données.
list = list(chaine = "hello", vecteur = c("ab", "ba", "abb"), matrice = matrix(data = 1:4, nrow=2, ncol = 2))
list## $chaine
## [1] "hello"
##
## $vecteur
## [1] "ab" "ba" "abb"
##
## $matrice
## [,1] [,2]
## [1,] 1 3
## [2,] 2 4list$vecteur## [1] "ab" "ba" "abb"Le data frame, une attention particulière sur ce dernier, elle est la structure la plus utilisée pour la manipulation de données, lecture de fichiers…
A la différence des matrices, les data frames peuvent comporter des colonnes de types différents. Conceptuellement chaque ligne représente un individu (client, produit…), et chaque colonne une variable (age, ville, type de contrat en cours…)
Le paramètre stringsAsFactors = FALSE sera expliqué un peu plus loin.
age = c(22, 44, 56, 18, 76, 33)
ville = c("Nantes", "Poitiers", "La Roche sur Yon", "Nantes", "Bordeaux", "Saint Herblain")
contrat = c("Forfait illimité", "Forfait 12G", "Forfait étranger", "Forfait bloqué", "Forfait bloqué", "Forfait prépayé")
df = data.frame(age=age, ville=ville, contrat=contrat, stringsAsFactors = FALSE)
dfAjout d’une colonne
anciennete = data.frame(anciennete=c(6, 3, 18, 36, 1, 43))
df = cbind(df, anciennete)
dfAjout d’une ligne
new.client = c(38, "Rennes", "Forfait étranger", 0)
df = rbind(df, new.client)
dfSuppression d’une colonne
df$age <- NULL
dfSuppression d’une ligne
df <- df[-c(2), ]
dfLecture de la structure
Pour lire un dataframe on s’appuie sur deux axes, le premier, l’axe des lignes qui comporte plusieurs index, le deuxième l’axe des colonnes, aussi à multiples index Aussi pour cibler une cellule en particulier, nous pouvons nous servir des deux axes, lignes+colonnes, qui donneront “les coordonnées” précises de son emplacement dans le data frame.
df[1:3,]df[,3]## [1] "6" "18" "36" "1" "43" "0"df[3,1]## [1] "Nantes"Le factor sert à représenter des valeurs catégorielles (Homme/Femme, Low/Medium/High, …), bien qu’il puisse aussi contenir des valeurs numériques. Il peut être vu comme un vecteur avec des informations aditionnelles, composées des valeurs distinctes de la série, appelées levels.
ft = factor(c("VIP", "Client à risque", "Neutre", "Client ancien", "Neutre", "Nouveau client", "Client à risque", "Client ancien"), levels = c("VIP", "Client ancien", "Neutre", "Nouveau client", "Client à risque"))
ft## [1] VIP Client à risque Neutre Client ancien
## [5] Neutre Nouveau client Client à risque Client ancien
## Levels: VIP Client ancien Neutre Nouveau client Client à risquePour revenir sur le paramètre stringsAsFactors = FALSE du data frame, si celui-ci est définit à TRUE, on ne pourra pas ajouter de nouvel élément hors de la liste prédéfinie, puisque ce dernier ne se trouvera pas parmi les levels existants.
| Structure de la donnée | Type R | Description |
|---|---|---|
| vecteur | c() | Liste d’éléments de même type |
| matrice | matrix() | Tableau à deux dimensions, où toutes les colonnes sont de même type |
| tableau multidimensionnel | array() | Tableau pouvant contenir N dimensions |
| liste | list() | Liste pouvant contenir tous les types de structure R |
| tableau à 2 dimensions | data.frame() | Tableau à 2 dimensions où les lignes représentent les individus, les colonnes les variables. Les colonnes peuvent être de type différent |
| facteur | factor() | Vecteur d’un ensemble de valeurs, avec la liste des modalités |