Cet article a été initialement publié ici.

Shiny-image1

Nous ne nous étendrons pas sur une présentation détaillée de R, langage de programmation très complet et principalement dédié aux statistiques (plus de détails ici), mais si vous ne connaissez pas déjà, ça vaut la peine d’y jeter un oeil ;)
Nous allons ici parler d’un package R en particulier, package très utile car il permet le calcul et la publication de résultats statistiques dynamiques sur le web : il s’agit du package “shiny”.

> Shiny : qu'est-ce que c'est ?

Shiny est un package R, développé par RStudio, qui permet la création de pages web interactives sur lesquelles il est possible de réaliser toutes les analyses / actions disponibles sous R.
Sa grande force est le fait qu’il n’y a absolument pas besoin de connaître ni HTML, ni CSS, ni JavaScript : tout est programmé uniquement en R !
C’est cela qui en fait un atout indéniable en faveur de R comme outil indispensable pour tout “data scientist” qui se respecte ;)

> Shiny : à quoi ça ressemble ?

Avant de plonger les mains dans le cambouis, voici un petit aperçu des possibilités offertes par le package “shiny” :

> Shiny : comment ça fonctionne ?

Après avoir au préalable installé le package “shiny” dans R, il faut créer son application shiny qui sera composée de deux fichiers : un fichier “ui.R” et un fichier “server.R”.

  • La partie “ui” : User Interface script, contrôle la mise en page et l’apparence de l’application.
  • La partie “server” : Server script, contient les instructions dont l’ordinateur a besoin pour construire l’application.

> Shiny : un premier exemple pas à pas

On commence par créer deux fichiers : “ui.R” et “server.R”, dans un même dossier : appelé par exemple “mon_appli”.

On va commencer par regarder la structure du fichier “ui.R” :

library(shiny) # il faut charger le package au début de chacun des scripts

shinyUI( pageWithSidebar( # mise en page shiny standard : éléments de contrôle à gauche et sorties à droite
  
  headerPanel("Premier exemple"), # titre de l'appli
  
  sidebarPanel( # cette partie va contenir tous les éléments de contrôle de l'UI
    
    textInput(inputId = "entree_texte", # nom associé à cet élément de contrôle, sera utilisé dans la partie 'server'
              label = "Entrez du texte :", # libellé associé à cet élément de contrôle
              value = "") # valeur par défaut
  ),
  
  mainPanel( # cette partie va contenir les sorties
    
    h3("Voici le texte que vous avez entré :"), # titre donné à la partie présentant les sorties, l'élément h3 correspond à une balise "<h3>" en html, ie. le titre sera mis en valeur
    
    textOutput("sortie_texte") # va permettre d'afficher une sortie de type 'texte', le contenu sera défini dans la partie 'server' avec comme nom de variable 'sortie_texte'
    
  )
  
))

Pour lancer votre application en local, deux options :

  • cliquer sur le bouton “Run App” en haut à droite de l’IDE “RStudio” si vous l’utilisez,
  • ou exécuter la commande suivante : runApp(“~/mondossier/mon_appli”).

Voilà à quoi ressemble l’application ainsi générée :

Shiny-image2

On va maintenant regarder la partie “server.R” qui a servi à cette appli :

library(shiny) # il faut charger le package au début de chacun des scripts

shinyServer( function(input, output) { # les éléments de la partie 'server' vont être définis ici
  
  output$sortie_texte <- renderText({ # fonction réactive 'shiny' utilisée pour afficher du texte dans une interface 'UI', ici le résultat de cet élément sera assigné à 'sortie_texte'
    
      paste0("Texte entré : ", input$entree_texte, 
             ". Ce texte comporte ", nchar(input$entree_texte), " caractères.")
      # la ligne ci-dessus permet de concaténer du texte (entre guillemets) et le texte récupéré depuis la partie 'UI' qui est stocké dans 'entree_texte'(NB: nchar() est une fonction R permettant le calcul du nombre de caractères dans une chaîne de caractères)
    
  })

})

=> Ce qu’il faut retenir ici c’est que les entrées seront lues depuis la partie UI, puis envoyées à la partie server pour être traitées, et le résultat de ce traitement sera ensuite restitué dans la partie UI. Tout ceci se produit de manière dynamique grâce aux fonctions réactives prévues dans “shiny”, telles que par exemple : * renderText() : pour restituer une chaîne de caractères, * renderPlot() : pour restituer des graphiques de type “plot”, * renderImage() : pour restituer un fichier d’image, * renderTable() : pour restituer un tableau, * etc…

Pour plus de détails sur le fonctionnement de la réactivité dans “shiny”, voir par exemple ici.


Nous allons maintenant reprendre notre premier exemple et le modifier légèrement afin d’y ajouter notamment un histogramme créé dynamiquement.
Voici le script “ui.R” utilisé :

library(shiny)

shinyUI( pageWithSidebar(
  
  headerPanel("Deuxième exemple"), # titre de l'appli
  
  sidebarPanel(
    
    textInput(inputId = "titre_histo", 
              label = "Entrez le titre souhaité pour l'histogramme :",
              value = "Histogramme"), # le texte entré ici va cette fois servir de titre pour l'histogramme qu'on va construire
    
    sliderInput("n_obs", # on va pouvoir spécifier ici le nombre d'observations qui seront générées pour construire l'histogramme
                "Nombre d'observations souhaité :", 
                value = 500, # la valeur par défaut est de 500 observations
                min = 100, # le nombre minimum d'observations possible est 100
                max = 1000) # le nombre maximum d'observations possible est 1000
    
  ),
  
  mainPanel(
    
    h3("Résultats :"), 
    
    plotOutput("mon_histo") # cette fois on aura une sortie de type 'plot' et non 'text'
    
  )
  
))

Et voici le script “server.R” utilisé :

library(shiny)

shinyServer( function(input, output) { 
  
  output$mon_histo <- renderPlot({ # on fait appel à la fonction 'renderPlot' cette fois car notre sortie sera un graphique
    
    
      set.seed(123) # ce paramètre sert à fixer une graine pour l'aléatoire lors de la génération de x (non indispensable)
    
      x = rnorm(input$n_obs) # x suit une loi normale et est constitué du nombre d'observations 'n_obs' spécifié par l'utilisateur dans la partie 'UI'
    
      hist(x, xlab = "x", ylab = "Fréquence",
           main = input$titre_histo, # le titre de notre histogramme (paramètre 'main') va être constitué du texte rentré à la main par l'utilisateur dans la partie 'UI' et stocké dans 'titre_histo'
           col = "skyblue", border = "white")
  })

})

L’application ainsi générée ressemble à présent à ceci :

Shiny-image3

Il existe un grand nombre d’éléments de contrôle tels que “textInput()” et “sliderInput()” vus ici, vous pouvez en trouver une galerie ici : “widget gallery”.


L’application que nous venons de présenter n’est qu’un exemple basique de ce qui peut être fait avec le package “shiny”, afin de vous donner un avant-goût de la puissance apportée par ce package, qui permet de générer des interfaces web dynamiques uniquement en quelques lignes de code R !

Voici un autre exemple d’application “shiny” plus complexe (réalisée notamment avec le package “shinydashboard”) pour vous donner un aperçu de ses immenses possibilités : demo.dacta.fr.

> Shiny : et ensuite ? Passer au déploiement

Une fois qu’on est satisfait de son appli “shiny”, il va falloir procéder à son déploiement, c’est-à-dire la mettre sur internet (pour l’instant tout avait été fait en local).
Pour cela plusieurs options :

  • soit passer par la plateforme “shinyapps.io” mise à disposition par RStudio (très pratique si on veut faire des tests ou partager rapidement son appli), qui propose notamment une offre d’hébergement gratuite pour 5 applications “shiny” actives,
  • soit passer par l’installation d’un serveur shiny (tout à fait faisable sur une instance AWS par exemple).

> Shiny : pour aller plus loin...

Ce que nous avons vu ici n’est qu’un petit aperçu des multiples possibilités offertes par ce package “shiny”, dont le champ d’applications est très vaste.

En effet, de nombreux packages viennent compléter son utilisation tels que par exemple des packages permettant la réalisation de graphiques dynamiques JavaScript dans R (ex: “rAmCharts”, “ggvis”, …) ou bien encore le package “shinydashboard” qui propose un design de “tableaux de bord” par défaut.
Il est également possible de compléter les fonctionnalités de R/shiny avec des widgets html codés en R, ou bien d’ajouter soi-même des éléments directement codés en HTML, CSS ou JavaScript.
Petite remarque assez intéressante : il est aussi possible d’intégrer facilement “Google Analytics” sur une application “shiny” déployée, afin d’analyser les différents visiteurs (voir par exemple ici).

Enfin, nous terminerons avec une liste de ressources qui pourront vous servir lors de vos futures créations d’applications “shiny” :

En espérant que cela vous aura donné envie de tester ce package, qui est pour moi un fort argument dans le choix de R comme langage pour tout projet "data".
Et pour ceux qui ont déjà créé de chouettes applications "shiny", n'hésitez pas à partager vos liens dans les commentaires ! ;)

Partager