Introduction

Un problème de data science commence toujours par les phases d’importation des données, leur nettoyage/validation puis une phase de transformation/mise en forme des données permettant ensuite leur modélisation. Ces 3 dernières étapes interagissent et il est souvent nécessaire de faire des aller retours entre la modélisation et la manipulation des données. D’ou l’intérêt de disposer d’un ensemble de fonctionnalités souples au sein d’un unique environnement.

 

 

Drawing
Data science diagram, voir “R for Data Science”, Garrett Grolemund et Hadley Wickham.

De nombreux outils sont disponibles dans R pour effectuer ces tâches. Nous proposons ici de parcourir les principaux packages/fonctions de base les plus utiles à nos yeux. Il ne s’agit pas d’une liste exhaustive ni définitive mais plutôt d’un panorama de base.

La suite tidyverse incluant les packages ggplot2 (graphiques), dplyr (manipulation de données), tidyr (nettoyage de données), readr (lecture de fichier plats “rectangulaires”: csv, tsv, fwf…), purrr (programmation fonctionnelle en R), tibble (variante de data frame) est un ensemble de packages très populaires de manipulation de données. Un contributeur majeur de ces packages est Hadley Wickham, chef scientist à RStudio et un des programmeurs R les plus populaire et prolifique.

Nous regarderons plus précisément le package dplyr dont les avantages sont multiples:

  • facile à prendre en main et fonctions intuitives, notamment si l’on possède un background sql dont s’inspire la syntaxe de dplyr
  • les fonctions de dplyr sont optimisées et permettent des traitements rapides
  • l’avantage du sql pour les requêtes, les fonctionnalités d’analyses statistiques des données en plus

un package similaire à dplyr est le package data.table (voir ici une discussion sur la comparaison des 2: https://stackoverflow.com/questions/21435339/data-table-vs-dplyr-can-one-do-something-well-the-other-cant-or-does-poorly).

Data Frames

L’objet permettant de stocker des tableaux de données en R est la data frame. Il s’agit d’une liste de vecteur de même taille, potentiellement de type (numeric, character) différent.

x1<-c(1:5)
x2<-c("a", "b", "c", "d", "e")
x3<-c(rep(TRUE, 3), rep(FALSE, 2))

data_test<-data.frame(x1, x2, x3)

Par défaut le nom des éléments de la liste est celui des vecteurs la constituant. Il est possible de les modifier via la fonction names():

names(data_test)<-c("var1", "var2", "var3")
data_test

Lorsqu’on affiche la data frame, la première ligne de la table, appelée header, contient le nom des colonnes. Les observations constituent les lignes de la table.

Pour connaitre les dimensions de la data frame, utiliser dim(), ncol() ou nrow().

Il est souvent pratique de visualiser les premières lignes de la table à l’aide de head()

head(data_test, 2)

Une fonction très utile, notamment lorsqu’on manipule des data frame est la fonction str, elle permet d’obtenir le type de chacune des variables de la data frame:

str(data_test)
## 'data.frame':    5 obs. of  3 variables:
##  $ var1: int  1 2 3 4 5
##  $ var2: Factor w/ 5 levels "a","b","c","d",..: 1 2 3 4 5
##  $ var3: logi  TRUE TRUE TRUE FALSE FALSE

La fonction summary() permet de calculer des statistiques de base de la data frame:

summary(data_test)
##       var1   var2     var3        
##  Min.   :1   a:1   Mode :logical  
##  1st Qu.:2   b:1   FALSE:2        
##  Median :3   c:1   TRUE :3        
##  Mean   :3   d:1                  
##  3rd Qu.:4   e:1                  
##  Max.   :5

Pour accéder à la colonne \(i\) de la table la commande est data_test$vari ou data_test[[i]] ou data_test[,"vari"]. Pour accéder à la cellule de la table correspondant à la ligne \(i\) et la colonne \(j\) l’instruction est data_test[i,j].

Remarquons que le type d’objet obtenu lorsqu’on sélectionne une variable de la data frame dépend de l’instruction:

x<-data_test$var1
str(x)
##  int [1:5] 1 2 3 4 5
x<-data_test[,1]
str(x)
##  int [1:5] 1 2 3 4 5
x<-data_test[ , "var1", drop = TRUE]
str(x)
##  int [1:5] 1 2 3 4 5
x<-data_test[ , "var1", drop = FALSE]
str(x)
## 'data.frame':    5 obs. of  1 variable:
##  $ var1: int  1 2 3 4 5

Pour ajouter une nouvelle variable à une data frame existante:

data_test$var4<-c(10:14)
data_test<-data.frame(data_test, var5=rep('statML', 5))
head(data_test)

Pour supprimer des colonnes dans une data frame, on peut exploiter la fonction subset

data_test_cut <- subset(data_test, select = -c(var1, var2) )
head(data_test_cut, 2)

ou utiliser les numéros des colonnes de la data frame:

data_test_cut <- data_test[, -c(1,2)]
head(data_test_cut, 2)

ou utiliser les noms des variables:

drop <- c("var1","var2")
data_test_cut <- data_test[,!(names(data_test) %in% drop)]
head(data_test_cut, 2)

Pour extraire un sous-ensemble de variables ou de colonne on peut de la même façon,

utiliser les numéros des colonnes de la data frame:

data_test_sub <- data_test[c(1,2)]
head(data_test_sub, 2)

utiliser les noms de variables:

keep <- c("var1","var2")
data_test_sub <- data_test[keep]
head(data_test_sub, 2)

utiliser la fonction subset():

data_test_sub <- subset(data_test, select = c(var1, var2) )
head(data_test_sub, 2)

tibbles

Les tibbles sont une variante des data frame, proposée par Hadley Wickham dans la suite de package “tidyverse”. Il s’agit d’une version moderne de data frame oubliant certains aspects désuets des data frame (convertion des caractères en facteurs, print pas très beau, amélioration de la détection des champs…). Pour une description détaillée faire vignette("tibble").

Il existe deux grandes différences entre les tibbles et les data frame: l’affichage et le découpage en sous-ensembles.

Affichage

La fonction print de la classe tibbles représente seulement les 10 premières lignes du tibble et un nombre de colonnes pouvant s’afficher à l’écran (on peut également customisé l’affichage avec options(tibble.print_max = n, tibble.print_min = m)). Le type de chaque variable est précisé. Considérons l’exemple des données de consommation électrique que nous manipulerons au cours des TP de modélisation suivants.

setwd("/Users/yannig/Documents/Enseignement/2019-2020/M2statML/Datasets/France/Data_France/")
Data0<-read_csv("Data0.csv")
Data0

On remarque que le type de chaque variable a été inféré lors de l’import des données. Par exemple, la variable Date est bien de type Date (et non une chaine de caractère comme ça l’aurait été avec la fonction d’import de csv du R de base).

Extraction de sous-ensembles

De même qu’avec le type data frame, pour extraire une variable il est possible d’utiliser: $, [[“nom”]], [[numero]].

Data0$Load%>%head
## [1] 51600 66500 71000 70700 72960 71800
Data0[["Load"]]%>%head
## [1] 51600 66500 71000 70700 72960 71800
Data0[[2]]%>%head
## [1] 51600 66500 71000 70700 72960 71800

Cela peut être inclu dans un pipe via l’indication “.”:

Data0%>%.$Load%>%head
## [1] 51600 66500 71000 70700 72960 71800
Data0%>%.[["Load"]]%>%head
## [1] 51600 66500 71000 70700 72960 71800
Data0%>%.[[2]]%>%head
## [1] 51600 66500 71000 70700 72960 71800

Pour l’extraction de lignes il est possible d’utiliser l’instruction de base:

Data0[1:4,]

pour des requêtes plus complexes il est plus commode (et conseillé) d’utiliser les fonctionnalités du package dplyr::select() et dplyr::filter(). Notons que, contrairement au R de base ou l’instruction [] peut renvoyer une data.frame ou un vecteur, avec tibble elle renvoie toujours un tibble.

Import des données à partir d’un fichier plat

Fonctions de base

Le type de fichiers plat le plus courant est le fichicher texte “.txt” délimité (tabulation, virgule, point virgule…). L’import de ce type fichiers plat en R se fait via la fonction read.table() dont il existe différentes variantes (read.csv(), read.delim()…) qui se distinguent selon les valeurs par défaut des paramètres suivants:

  • le séparateur
  • le “header” (la première ligne contient le nom des variables ou pas)
  • l’argument fill, fill=TRUE signifie que si les lignes ne sont pas de même taille, les trous sont comblés par des champs vides.

Ces fonctions supposent que les données du fichier texte soient organisées telles que les lignes soient les observations, les colonnes les variables.

Un autre type de fichier couramment utilisé est le fichier excel “.xls”. Il existe le package XLConnect dont la fonction readWorksheetFromFile() réalise l’import de feuilles excel.

library(XLConnect)
XLdata <- readWorksheetFromFile("<file name and extension>", sheet = 1)

Le format JSON (JavaScript Object Notation) est un format de données populaire utilisé pour la lecture, le stockage et l’échange d’information (notamment sur le web, Yahoo et Google utilisent JSON dès 2005 et 2006). La plupart des languages informatiques peuvent générer et lire le format JSON. Il est donc devenu très populaire pour le stockage, la lecture et le partage d’information dans les applications et services web. Il existe le package rjson dont la fonction fromJSON() réalise l’import de fichier.

library(rjson)
JsonData <- fromJSON(file= "<filename.json>" )

Pour importer et manipuler des données au format XML, il existe le package XML, la fonction xmlTreeParse() permet d’analyser directement des données du web:

library(XML)
xmlfile <- xmlTreeParse("<Your URL to the XML data>")

il faut ensuite manipuler les données ainsi importées (toujours au format XML) à l’aide des fonctions xmlSApply(), xmlRoot()… pour se construire une data.frame.

Gestion des dates: fonctions de base

La particularité des données de série temporelle est leur indexation par le temps. Une bonne gestion de ces données passe donc bien souvent par la gestion d’un format de date adéquate. Nous reviendrons sur ces formats plus en détail dans la suite.

Pour préciser la classe d’une colonne de données, il est possible d’utiliser l’argument colClasses de la fonction read.csv et préciser s’il s’agit du type “Date”,“numeric”,“character” ou “factor”. Dans l’exemple suivant, l’instruction:

internet_trafic <- "/Users/yannig/Documents/Enseignement/2019-2020/M2statML/Datasets/internet-traffic-data-in-bits-fr.csv"
data <- read.csv(internet_trafic, dec = ".", sep = ",", header = F, 
    skip = 1, colClasses = c("Date", "numeric"))

précise que la 1ère colonne des données est de la classe Date, et la 2e de la classe numeric. Toutefois, par défaut le format de la classe Date créée est au format “%Y-%m-%d” (ex: 2004-11-19). Pour gérer des formats plus spécifiques, comme c’est le cas ici, une possibilité est soit d’importer les données au format caractère puis de convertir la chaine de charactère correspondant à la date à l’aide des fonctions as.POSIXct et strptime:

data <- read.csv(internet_trafic, dec = ".", sep = ",", header = F, 
    skip = 1)
tail(data$V1)
Date <- as.POSIXct(strptime(data$V1, "%Y-%m-%d %H:%M:%S"))
Traffic <- as.numeric(data$V2)
data <- data.frame(Date, Traffic)

soit de définir un format personalisé en amont de l’importation de la table:

setClass("myDate")
setAs("character", "myDate", function(from) as.POSIXct(strptime(from, 
    "%Y-%m-%d %H:%M:%S")))
data <- read.csv(internet_trafic, dec = ".", sep = ",", header = F, 
    skip = 1, colClasses = c("myDate", "numeric"), col.names = c("Date", 
        "Traffic"))

Une fois importé, il est indispensable de vérifier la cohérence des données. Pour cela, utilisez la fonction head (resp. tail) qui permettent d’afficher les premières (resp. dernières) lignes des données, et la fonction summary qui calcul les statistiques de base pour chacune des variables de la table.

head(data)
tail(data)
summary(data)
##       Date                        Traffic     
##  Min.   :2004-11-19 09:30:00   Min.   : 1060  
##  1st Qu.:2004-12-06 15:48:45   1st Qu.: 2364  
##  Median :2004-12-23 22:07:30   Median : 3494  
##  Mean   :2004-12-23 22:07:30   Mean   : 3867  
##  3rd Qu.:2005-01-10 04:26:15   3rd Qu.: 4889  
##  Max.   :2005-01-27 10:45:00   Max.   :10671

Gestion des dates: lubridate

Lubridate permet de simplifier la gestion des dates en automatisant ce processus. Lubridate contient un certaint nombre de fonctions qui analysent et détectent le format date de vos données.

Par exemple:

library(lubridate)
ymd("20171006")
## [1] "2017-10-06"
mdy("06-10-2017")
## [1] "2017-06-10"
dmy("06/10/2017")
## [1] "2017-10-06"
ymd_hms("2017-10-06 14:30:00")
## [1] "2017-10-06 14:30:00 UTC"

Dans le cas de date incluant l’heure il est important de préciser le fuseau horaire (liste des time zones ici: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones):

ymd_hms("2017-10-06 14:30:00", tz = "GMT")
## [1] "2017-10-06 14:30:00 GMT"

Le package lubridate propose des fonctions utiles pour la gestion des fuseaux horaires, comme with_tz() et force_tz().

date_today <- ymd_hms("2017-10-06 14:30:00", tz = "GMT")
with_tz(date_today, "America/Guyana")
## [1] "2017-10-06 10:30:00 -04"

Il est également possible d’extraire (ou modifier) de l’information d’une date à l’aide des fonctions second(), minute(), hour(), day(), wday(), yday(), week(), month(), year(), et tz().

date_today <- ymd_hms("2017-10-06 14:30:00", tz = "GMT")
hour(date_today)
## [1] 14
hour(date_today) <- 15
date_today
## [1] "2017-10-06 15:30:00 GMT"
wday(date_today, label = T)
## [1] Fri
## Levels: Sun < Mon < Tue < Wed < Thu < Fri < Sat

readr

Il existe dans readr 7 fonctions de base pour l’import de fichiers plats.

Pour plus de détails sur les arguments de ces fonctions voir l’aide ?read_csv.

Pour inférer le type d’une variable, les fonctions développées dans readr procèdent à une heuristique consistant à lire les 1000 premières observations et à déduire via des règles simples le type de chaque variable.

L’algorithme essaye les types suivants:

  • logical: si le champ contient seulement “F”, “T”, “FALSE”, ou “TRUE”.
  • integer: si le champ contient seulement des charactères numériques et -.
  • double: si le champ contient seulement des réels valides (incluant les valeurs de type 4.5e-5).
  • number: si le champ contient seulement des réels valides avec des marqueurs de groupe (virgule, millier, millions…)
  • time: correspond au format par défaut time_format.
  • date: correspond au format par défaut date_format.
  • date-time: ISO8601 date.

si le champ n’est dans aucun de ces cas la, il reste une chaîne de charactère.

Cette heuristique peut parfois être mise en défaut et il faut alors agir plus spéficiquement. La fonction problems() permet d’obtenir un tibble des erreurs d’analyse associées à chaque colonne et permet de remonter à la source de certains problèmes de type anomalie dans les données, valeurs manquantes etc.

Plusieurs arguments sont en faveur de l’utilisation de ces fonctions d’import plutôt que celles de base:

  • reproductibilité sur un autre PC: les fonctions du R de base sont souvents dépendantes de paramètres locaux (OS, variables d’environnement)
  • rapidité: environ 10 fois plus rapides que les fonction de R base. Barre de progrès très utile pour les gros volumes de données.
  • importe directement en type tibble.

Quelques exemples

Considérons l’exemple jouet suivant. Un tableau de données df1.csv est composé de deux colonnes x et y et 3 contenant sur 3 lignes les valeurs respectivement 1 2 “a” et 1.1, 1.2, 1.3. Imaginons ici que l’algorithme d’inférence du type de chaque champ se base sur les n=2 premières lignes au lieu des 1000 par défaut. Voilà ce que nous obtenons lors de l’import:

df<-read_delim("/Users/yannig/Documents/Enseignement/2019-2020/M2statML/Datasets/dplyr_exemples/df1.csv", delim=';', guess_max = 2)
df

Nous constatons que le charactère “a” est vu comme valeur manquante et que l’import renvoie un warning que l’on peut étudier plus précisément ainsi:

pb<-problems(df)
pb

On lit bien que l’erreur est survenue sur la colonne x à la ligne 3, que l’algorithme attendait un entier et qu’il a observé “a”. On peut ensuite corriger cette valeur ou la laisser manquante selon les connaissances qu’on a du problème étudié.

Imaginons maintenant que l’algorithme se base sur toutes les lignes pour inférer le type des données:

df<-read_delim("/Users/yannig/Documents/Enseignement/2019-2020/M2statML/Datasets/dplyr_exemples/df1.csv"
               , delim=';')
df
problems(df)

Dans ce cas l’algorithme ne signale pas d’erreur mais a choisi le type “character” pour la colonne x. On peut forcer ce champs à être un entier. On obtient ainsi la même erreur:

df<-read_delim("/Users/yannig/Documents/Enseignement/2019-2020/M2statML/Datasets/dplyr_exemples/df1.csv", 
               locale=locale(decimal_mark = ".", grouping_mark = ","), 
               delim=';', col_types = cols(x = col_integer(), y = col_number()))
df
problems(df)

Web scraping: récupération de données sur le web

Il existe plusieurs moyens de se procurer des données sur le web:

  • le classique copier/coller de tableau, graphiques… C’est une technique efficace dans bien des cas, mais qui nécessite l’intervention d’un utilisateur humain et qu’il est impossible d’automatiser.
  • recherche de patterns textuels: beaucoup d’informations sur les pages web sont du texte, pour traiter ce type de données il faut savoir manipuler des expressions régulières (en R ou autre language de programmation)
  • API (Applications Programming Interface): de nombreux sites/applications mettent à disposition des interfaces d’accès (gratuites ou payantes) à une partie (parfois restreinte) de leurs données. Par exemple Facebook, Twitter, Linkedin… Les données peuvent ainsi être extraites dans un format spécifié.
  • Document Parsing: via les web brosers, il est possible de programmer des analyses automatiques de page web afin d’en extraire l’information utile (notamment l’information dynamique).

Packages XML et RCurl

Le format html est lisible par la fonction readHTMLTable du même package XML. Il peut être couplé avec le package RCurl un wrapper pour la librairie de fonction pour les transferts de fichiers libcurl (FTP, FTPS, HTTP, HTTPS…).

library(XML)
library(RCurl)
eurl <- getURL("<a URL>", .opts = ...)
data_df <- readHTMLTable(url, which=3) ##tableau N°3 de l'url

Il faut bien souvent écrire des script R spécifiques pour convertir ces tableaux dans un format compatible pour leur analyse.

Par exemple, le script suivant permet d’aller chercher le tableau de la population de tous les pays du monde sur une page wikipedia puis d’en faire la somme pour en déduire la population mondiale:

library(XML)
library(RCurl)
u<-"https://en.wikipedia.org/wiki/List_of_countries_and_dependencies_by_population"
theurl <- getURL(u, .opts = list(ssl.verifypeer = FALSE) )
tables = readHTMLTable(theurl, header=T)

Data<-tables[[1]]
head(Data, 3)
Data$Population<-gsub(",", "", Data$Population)%>%as.numeric
sum(Data$Population)
## [1] 7610592487

Manipulation des données: fonctions de base de dplyr

Le tableau ci-dessous contient l’ensemble des fonctions de base du package dplyr que nous présentons dans ce tutoriel.

Gestion des doublons: fonction distinct()

Cette fonction permet de supprimer des doublons dans une table. Ces doublons pouvant être défini à partir d’une ou d’un ensemble de variables.

Considérons l’exemple des données de consommation électrique. On peut vérifier qu’il n’y a pas de doublons:

x1 <- distinct(Data0)
dim(Data0)
## [1] 1339   24
dim(x1)
## [1] 1339   24

On peut également sélectionner les lignes possédant une unique valeur de type de jour. Bien sur cette sous matrice n’est pas forcément unique, la fonction ne conserve alors que la première occurence. L’option .keep_all=FALSE ne conserve que la variable ayant permis de faire la sélection, .keep_all=TRUE conserve toutes les variables.

x2 <- distinct(Data0, Dow, .keep_all= F)
dim(x2)
## [1] 7 1
head(x2)

Sélectionner les lignes possédant une unique valeur de type de jour et de mois de l’année:

Data0$Month<-format(Data0$Date, "%m")
x3 <- distinct(Data0, Dow, Month, .keep_all= F)
dim(x3)
## [1] 84  2
head(x3)

Gestion des colonnes: fonction select()

La fonction select permet de sélectionner des variables en exploitant les informations contenues dans leurs noms.

On peut ainsi sélectionner des colonnes d’un tableau selon leur nom:

Meteo<-select(Data0, T_REAL, NEB_REAL, VENT_REAL)
head(Meteo)

ou les variables dans notre table liées à la consommation électrique:

Load<-select(Data0, starts_with("Load"))
head(Load)

toutes les variables dans une table exceptée un sous ensemble:

Meteo2<-select(Meteo, -T_REAL, -NEB_REAL)
head(Meteo2)

un sous-ensemble de colonnes successives avec l’opérateur “:”

Data1<-select(Data0, Date:T_REAL)
head(Data1)

Gestion des lignes: fonction filter()

La fonction filter permet de sélectionner des lignes de la table en fonction de règles logiques.

Par exemple, selectionner les lignes pour laquelle la température réalisée est supérieure à 16 degrés:

Data0_hot<-filter(Data0, T_REAL >= 16)
summary(Data0_hot$T_REAL)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   16.00   18.00   20.00   20.51   22.60   29.70

selectionner les lignes pour laquelle la température réalisée est supérieure à 16 degrés et la consommation inférieure à 50000MW:

Data0_hot2<-filter(Data0, T_REAL >= 16, Load<50000)  ## équivalent à Data0_hot2<-filter(Data0, T_REAL >= 16 & Load<50000)
summary(Data0_hot2$Load)
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   39388   43743   46488   45798   47700   49991
summary(Data0_hot2$T_REAL) 
##    Min. 1st Qu.  Median    Mean 3rd Qu.    Max. 
##   16.00   18.48   20.40   20.63   22.65   28.77

sélectionner uniquement les samedi et dimanche:

Data0_week_end<-filter(Data0, Dow %in% c("samedi", "dimanche"))
head(Data0_week_end$Dow)
## [1] "dimanche" "samedi"   "dimanche" "samedi"   "dimanche" "samedi"

sélectionner les lignes pour lesquelles 2013 apparait dans la variable date:

Data0_2013 <- filter(Data0, grepl("2013", Date))
summary(Data0_2013$Date)
##                  Min.               1st Qu.                Median 
## "2013-01-01 12:00:00" "2013-04-02 12:00:00" "2013-07-02 12:00:00" 
##                  Mean               3rd Qu.                  Max. 
## "2013-07-02 12:00:00" "2013-10-01 12:00:00" "2013-12-31 12:00:00"

Création de variable: fonction mutate()

La fonction mutate() permet de créer des nouvelles variables (colonnes) fonctions d’autres variables dans la table. C’est une fonction très utile lors de la phase de feature engeneering.

Par exemple, pour créer les variables Year, Month et Day à partir de la variable Date on procède ainsi:

Data0 <- mutate(Data0, Year = format(Date, "%Y"), Month = format(Date, "%m"),
                Day = format(Date, "%d"))
select(Data0, Year:Day)  

Il est possible de se référer dans la fonction aux variables que l’on vient de créer:

Data0 <- mutate(Data0, Delta = T_REAL-T_NORM, Delta2 = Delta^2)
select(Data0, Delta, Delta2)  

La variante transmute() ne concerve que les vartiables créées.

Quelques exemples de transformations utiles/courantes:

  • opérations arithmétiques de base: +, -, *, /, ^
  • autres opérations arithmétiques: %/% division d’entiers, %% (reste), floor() (partie entière), trunc()
  • transformation logarithmiques: log(), log2(), log10() pour gérer des données de différentes magnitudes, transformer des modèles multiplicatifs en modèles additifs plus simples à manipuler
  • avance et retard: lead() et lag() pour les données temporelles notamment, utile également pour détecter les ruptures dans des séries d’observations lag(x)!=x
  • min(), max() et quantiles quant()
  • les rangs: rank(), (dplyr::min_rank la version dplyr)
  • comparaisons logique: <, <=, !=…
  • agrégations temporelles, lissages: cumsum(), cumprod(), cummin(), cummax(), dplyr::cummean(), stats::filter

Manipulation de plusieurs jeux de données

Dans de nombreux cas pratiques, il est nécessaire de manipuler plusieurs jeux de données pour batir un modèle prédictif efficace. Par exemple, la prévision de la consommation électrique nécessite la prise en compte d’informations météorologique. Les données de consommation et les données météos provenant de différentes sources, il faut pouvoir fusionner ces deux tables. La package dplyr propose un ensemble de fonction facilitant cette tache.

Considérons l’exemple suivant. Nous commençons par créer 2 data frames df1 et df2.

df1 <- data.frame(ID = c(1, 2, 3, 4, 5),
                  w = c('a', 'b', 'c', 'd', 'e'),
                  x = c(1, 1, 0, 0, 1),
                  y=rnorm(5),
                  z=letters[1:5])

df2 <- data.frame(ID = c(1, 7, 3, 6, 8),
                  a = c('z', 'b', 'k', 'd', 'l'),
                  b = c(1, 2, 3, 0, 4),
                  c =rnorm(5),
                  d =letters[2:6])

df1
df2

la fonction inner_join() permet de renvoyer une table jointe dont les lignes sont les lignes dont la clé primaire est la même dans les deux tables et dont les colonnes sont la concaténation des colonnes des 2 tables. Si la clé primaire n’a pas le même nom dans les 2 tables il est possible de le préciser via l’argumebt by=.

df3 <- inner_join(df1, df2, by = "ID")
df3

la fonction left_join() (resp. right_join())fait le même type d’opération mais en conservant toutes les lignes de la première table et en ajoutant des valeurs manquantes pour les lignes non renseignées.

df4 <- left_join(df1, df2, by = "ID")
df4

Il existe également des fonction permettant de fusionner des tables verticalement:

  • intersect() sélectionne les lignes apparaissant dans x et y
  • union() sélectionne les lignes apparaissant soit dans x soit dans y
  • setdiff() sélectionne les lignes apparaissant dans x et pas dans y
df5 <- dplyr::intersect(df1[1:4,], df1[3:5,])
df5

Analyse descriptive

Statistiques descriptives avec dplyr: fonction summarise()

Permet d’appliquer des fonctions génériques ou définies spécifiquement aux varibles de la table.

De manière univariée:

summarise(Data0, Load_max = max(Load), Load_mean=mean(Load), corr_lag=cor(Load, LoadLag1))

ou multivariée:

summarise_at(Data0, vars(T_REAL, NEB_REAL, VENT_REAL), funs(min, mean, median, max))
summarise_at(Data0, vars(T_REAL, NEB_REAL, VENT_REAL), function(x) max(x) - min(x))

On peut également introduire une condition:

summarise_if(Data0, is.numeric, funs(mean,median))