Power Query & R – Transformation avec Dplyr


Power Query et son interface permettent de réaliser facilement des transformations simples.

 

En programmant en langage M, nous pouvons réaliser des transformations plus complexes, mais il faut bien reconnaître que la difficulté dans la programmation devient vite prohibitive.

Microsoft l’a semble-t-il bien compris, en intégrant le langage R à Power Bi.

Ce langage, utilisé par les data scientists du monde entier, permet de réaliser ces opérations bien plus facilement.

Pour utiliser R dans Power Query, vous devrez tout d’abord mettre en place l’environnement sur votre ordinateur.

Une fois l’environnement installé, nous allons devoir installer un package R nommé ‘dplyr’

  • Ouvrez R studio
  • Tapez
    install.packages("dplyr")
  • Fermez Rstudio

Voila c’est fait !

Maintenant nous pouvons créer une nouvelle requête dans Power BI :

Normalement vous devriez obtenir ceci :

 

Maintenant nous allons pouvoir créer une nouvelle étape de transformation en créant un script R.

 

 

  • Copiez-collez ce script :
  • library(dplyr)
    sleepData <- head(dataset)
  • Cliquez sur Ok

 

Ce script permet d’afficher les six premières lignes du Dataset et de l’affecter à la variable sleepData à l’aide de l’opérateur « <-« .

Notez que la librairie a du être chargée par la commande library().

Nous pouvons maintenant étudier les principales commandes de cette librairie.

Selectionner des colonnes avec select()

 

Revenons sur notre script et modifions le de la sorte :

  • library(dplyr)
    sleepData <- head(select(dataset,genus, vore))

En utilisant le signe « -«  nous pouvons sélectionner toutes les colonnes à l’exception d’une seule (ici name) :

  • sleepData <- head(select(dataset,-name))

Pour sélectionner toutes les colonnes commençant par « sl » :

  • sleepData <- head(select(dataset,starts_with("sl")))

Pour sélectionner une plage de colonnes :

  • sleepData <- head(select(dataset,name:order))

Pour sélectionner les colonnes finissant par e :

  • sleepData <- head(select(dataset,ends_with("e")))

Pour sélectionner des colonnes contenant « en » :

  • sleepData <- head(select(dataset,contains("en")))

Pour sélectionner des colonnes en utilisant une expression régulière :

  • sleepData <- head(select(dataset,matches("^n")))

Selectionner des lignes avec filter()

 

Avec dplyr, nous pouvons réaliser des filtres élaborés en toute simplicité.

Par exemple :

    • sleepData <- filter(dataset,sleep_total>=16)

Retourne les lignes du dataset, pour le critère sleep_total>=16.

Nous pouvons affiner ce filtre en ajoutant autant de critères que nous le souhaitons :

  • sleepData <- filter(dataset,sleep_total>=16, bodywt>=1)

Si nous souhaitons spécifier un ensemble de valeurs, nous devrons utiliser un vecteur R, qui se présente sous cette forme : c(1,2,3, »hello », »bonjour »).

 

Par exemple :

 

  • sleepData <- filter(dataset,genus %in% c("Aotus","Capri")

Utiliser la notation « pipe » %>%

 

Cet opérateur est particulièrement utile lorsque vous souhaiterez utiliser des fonctions à l’intérieur d’autres fonctions.

Sans le pipe, il faut imbriquer les fonctions, ce qui peut vite devenir illisible et source d’erreurs.

Par exemple nous avons vu deux fonctions imbriquées:

  • sleepData <- head(select(msleep, name, sleep_total))

select() est imbriquée dans head().

Avec le pipe, c’est nettement plus simple :

  • sleepData <- dataset %>% select(name,sleep_total) %>% head()

Le pipe fait entrer dataset en premier paramètre de select(), puis l’expression complète « select(dataset,name,sleep_total) » en premier paramètre de head().

 

Trier les lignes avec arrange()

 

Pour effectuer un tri simple, par exemple trier les données par nom :

 

  • sleepData <- dataset %>% arrange(name)

Pour effectuer un tri multiple :

  • sleepData <- dataset %>% arrange(vore,name)

Pour trier les lignes par ordre descendant, vous devrez utiliser la fonction desc().

  •  sleepData <- dataset %>% arrange(vore,desc(name))

Nous pouvons évidemment appliquer plusieurs opérations chaînées, sur le dataset, par exemple sélectionner, filtrer, trier… :

  • sleepData <- dataset %>%
    select(name,genus,vore,order,sleep_total) %>%
    filter(sleep_total>8) %>%
    arrange(desc(name)) %>%
    head()

 

Créer de nouvelles colonnes calculéesavec mutate()

Le processus est encore plus simple qu’avec Power Query :

  • sleepData <- dataset %>%
    mutate(proportion = sleep_rem / sleep_total)

Nous pouvons créer à la volée, autant de colonnes calculées que nous le souhaitons, en séparant les arguments par un virgule :

  • sleepData <- dataset %>%
    mutate(proportion = sleep_rem / sleep_total, poids_gramme = bodywt*1000, etc...)

Calculs statistiques avec summarise().

R est l’un des langages les plus utilisés en data science, qui inclut le calcul statistique.

Une fois le dataset en forme, nous allons pouvoir aisément pouvoir effectuer des calculs statistiques, par exemple des moyennes :

  • sleepData <- dataset %>%
    summarise(moyenne = mean(sleep_total))

Il y a beau coup d’autres fonctions statistiques que vous pouvez utiliser avec summarise():

  • sd() pour l’écart type.
  • min() pour la valeur minimale.
  • max() pour la valeur maximale.
  • median() pour la valeur médiane de la série.
  • sum() pour la somme de la série.
  • n() pour le nombre de valeurs.
  • first() pour la première valeur.
  • last() pour la dernière valeur.

Il est donc possible de construire facilement un tableau reprenant les principales statistiques des valeurs d’une colonne :

  • sleepData <- dataset %>%
    summarise(avg_sleep = mean(sleep_total),
    min_sleep = min(sleep_total),
    max_sleep = max(sleep_total),
    total = n())

Grouper avec group_by()

Calculer une statistique sur l’ensemble des valeurs d’une colonne peut présenter un intérêt, mais le plus souvent vous voudrez par exemple calculer une moyenne par catégorie.

Dans ce cas, il vous suffira d’utiliser la fonction group_by() :

  • sleepData <- dataset %>%
    group_by(order) %>%
    summarise(avg_sleep = mean(sleep_total), min_sleep = min(sleep_total), max_sleep = max(sleep_total), total = n())

 

 

Comme nous pouvons le constater R permet de décupler les capacités de powerquery.

 

Laissez un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec *