Tutoriel R Shiny: tout ce que vous devez savoir

Ce didacticiel R Shiny vous fournira une connaissance détaillée et complète de R Shiny et comment créer des applications Web interactives.

Avec l'évolution de la technologie, de nouveaux outils et cadres sont apparus pour créer des applications Web qui affichent des statistiques, des cartes et des graphiques en temps réel. Étant donné que ces fonctionnalités nécessitent un traitement et une synchronisation élevés, les langages de programmation sont utilisés pour réduire le temps de chargement du serveur. Dans ce didacticiel R Shiny, je vais vous expliquer comment tirer le meilleur parti de R sur les applications Web dynamiques.



Nous couvrirons et comprendrons les sujets suivants:



Qu'est-ce que R Shiny?

Shiny est un package R qui permet aux utilisateurs de créer des applications Web interactives. Cet outil crée une application Web équivalente au HTML à partir du code Shiny. Nous intégrons du code HTML et CSS natif aux fonctions R Shiny pour rendre l'application présentable. Shiny combine la puissance de calcul de R avec l'interactivité du Web moderne.Shiny crée des applications Web qui sont déployées sur le Web à l'aide de votre serveur ou des services d'hébergement de R Shiny.

Caractéristiques de R Shiny:

  • Créez des applications simples avec une connaissance de base ou aucune connaissance des outils Web
  • Intégrez Shiny aux outils Web natifs pour améliorer la flexibilité et la productivité
  • Fonctions d'E / S et de rendu prédéfinies
  • Rendu facile du contenu de l'application sans recharges multiples
  • Fonctionnalité pour ajouter des sorties calculées (ou traitées) à partir de scripts R
  • Ajoutez des rapports et des visualisations en direct.

Cela nous amène à la question:



En quoi Shiny est-il différent des applications traditionnelles?

Prenons un exemple d'application météo, chaque fois que l'utilisateur actualise / charge la page ou modifie une entrée, il doit mettre à jour la page entière ou une partie de la page en utilisant JS. Cela ajoute de la charge côté serveur pour le traitement. Shiny permet à l'utilisateur d'isoler ou de rendre (ou de recharger) des éléments dans l'application, ce qui réduit la charge du serveur. Faire défiler les pages était facile dans les applications Web traditionnelles, mais était difficile avec les applications Shiny. La structure du code joue le rôle principal dans la compréhension et le débogage du code. Cette fonctionnalité est cruciale pour les applications brillantes par rapport aux autres applications.

à quoi sert la science des données

Passons au sujet suivant du didacticiel R Shiny, en installant le package R Shiny.

Installation de R Shiny

L'installation de Shiny revient à installer n'importe quel autre package dans R. Allez à Console R et exécutez la commande ci-dessous pour installer le package Shiny.



install.packages ('brillant')

Installer R Shiny - Tutoriel R Shiny - Edureka

Une fois que vous avez installé, chargez le package Shiny pour créer des applications Shiny.

bibliothèque (brillant)

Avant d'aller plus loin dans ce didacticiel R shiny, voyons et comprenons la structure d'une application Shiny.

Structure d'une application Shiny

Shiny se compose de 3 composants:

  1. Interface utilisateur
  2. Serveur
  3. ShinyApp

un.Fonction d'interface utilisateur

Interface utilisateur La fonction (UI) définit la disposition et l'apparence de l'application. Vous pouvez ajouter des balises CSS et HTML dans l'application pour rendre l'application plus présentable. La fonction contient toutes les entrées et sorties à afficher dans l'application. Chaque élément (division ou onglet ou menu) à l'intérieur de l'application est défini à l'aide de fonctions. Ceux-ci sont accessibles à l'aide d'un identifiant unique, comme les éléments HTML.Apprenons-en plus sur diversfonctions utilisées dans l'application.

Fonctions de mise en page brillantes

  • headerPanel ()ajoutez un en-tête à l'application. titlePanel () définit le sous-titre de l'application. Voir l'image ci-dessous pour une meilleure compréhension de headerPanel et titlePanel .
  • Barre latérale Disposition ()définit la disposition à tenir sidebarPanel et Panneau principal éléments. La disposition divise l'écran de l'application en panneau de barre latérale et panneau principal. Par exemple, dans l'image ci-dessous, le rectangle rouge est le Panneau principal la zone et la zone du rectangle noir verticalement est sidebarPanel région.

  • wellPanel ()définit un conteneur qui contient plusieurs objets d'entrée / sortie d'application dans la même grille.
  • tabsetPanel ()crée un conteneur pour contenir les onglets. tabPanel () ajoute un onglet dans l'application en définissant des éléments et des composants d'onglet. Dans l'image ci-dessous, le noirle rectangle est tabsetPanel objet et le rectangle rouge est le tabPanel objet.
  • navlistPanel ()fournit un menu latéral avec des liens vers différents panneaux d'onglets similaires à tabsetPanel () comme une liste verticale sur le côté gauche de l'écran. Dans l'image ci-dessous, le rectangle noir est navlistPanel objet et le rectangle rouge est le tabPanel objet.

En plus des fonctions de mise en page Shiny, vous pouvez également ajouter du CSS en ligne à chaque widget d'entrée de l'application.L'application Shiny intègre des fonctionnalités des technologies Web ainsi que des fonctionnalités et des fonctions R brillantes pour enrichir l'application. Utilisez des balises HTML dans l'application Shiny en utilisant balises $.

Votre mise en page est prête, il est temps d'ajouter des widgets dans l'application. Shiny fournit divers éléments d'entrée et de sortie utilisateur pour l'interaction de l'utilisateur. Laissez-nous discuter de quelques fonctions d'entrée et de sortie.

Fonctions d'entrée brillantes

Chaque widget d'entrée a une étiquette, un identifiant, d'autres paramètres tels que le choix, la valeur, sélectionné, min, max, etc.

  • selectInput ()- créer un élément HTML déroulant.
selectInput ('select', h3 ('Select box'), choix = liste ('Choice 1' = 1, 'Choice 2' = 2, 'Choice 3' = 3), selected = 1)

  • numericInput ()- zone de saisie pour saisir un nombre ou du texte.
dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Entrez du texte...')

  • boutons radio ()- créer des boutons radio pour l'entrée utilisateur.
radioButtons ('radio', h3 ('boutons radio'), choix = liste ('Choix 1' = 1, 'Choix 2' = 2, 'Choix 3' = 3), sélectionné = 1)

Fonctions de sortie brillantes

Shiny fournit diverses fonctions de sortie qui affichent R des sorties telles que des graphiques, des images, des tableaux, etc. qui affichent les R objet.

  • plotOutput ()- afficher l'objet de tracé R.
plotOutput'top_batsman ')
  • tableOutput ()- affiche la sortie sous forme de tableau.
tableOutput'player_table ')

2. Fonction serveur

Serveur fonction daffine la logique côté serveur de l'application Shiny. Cela implique la création de fonctions et de sorties qui utilisent des entrées pour produire divers types de sorties. Chaque client (navigateur Web) appelle la fonction serveur lors du premier chargement de l'application Shiny. Chaque sortie stocke la valeur de retour des fonctions de rendu.

Ces fonctions capturent une expression R et effectuent des calculs et un prétraitement sur l'expression. Utilisez la fonction render * qui correspond à la sortie que vous définissez. Nous accédons aux widgets d'entréeen utilisant entrée $ [widget-id] . Ces variables d'entrée sont des valeurs réactives. Toutes les variables intermédiaires créées à l'aide de variables d'entrée doivent être rendues réactives à l'aide de réactif ({}) . Accédez aux variables en utilisant ().

rendre * Les fonctions effectuent le calcul à l'intérieur de la fonction serveur et stockent dans les variables de sortie. La sortie doit être enregistrée avec sortie $ [nom de la variable de sortie] . Chaque rendre * La fonction prend un seul argument, c'est-à-dire une expression R entourée d'accolades, {}.

3. Fonction ShinyApp

shinyApp ()la fonction est au cœur del'application qui appelle OIGNON et serveur fonctions pour créer une application Shiny.

L'image ci-dessous montre le contour de l'application Shiny.

Passons au segment suivant du didacticiel R Shiny pour créer la première application R Shiny.

Créer un projet Web brillant

définir le chemin de classe pour java

Aller à Fichier et créer un Nouveau projet dans n'importe quel répertoire -> Application Web brillante -> [Nom du répertoire d'application Shiny]. Entrez le nom du répertoire et cliquez sur D'accord .

Chaque nouveau projet d'application Shiny contiendra un exemple d'histogramme pour comprendre les bases d'une application brillante. L'application d'histogramme contient un curseur suivi d'un histogramme qui met à jour la sortie pour une modification du curseur. Vous trouverez ci-dessous la sortie de l'application d'histogramme.

Pour exécuter l'application Shiny, cliquez sur le Lancer l'application bouton dans le coin supérieur droit du volet source. L'application Shiny affiche un widget de curseur qui prend le nombre de bacs en entrée et rend l'histogramme en fonction de l'entrée.

Maintenant que vous avez compris la structure et comment exécuter une application Shiny. Passons à la création de notre première application Shiny.

Créez la première application Shiny

Vous pouvez soit créer un nouveau projet, soit continuer dans le même répertoire de travail. Dans ce didacticiel R Shiny, nous allons créer une application Shiny simple pour afficher les statistiques IPL. L'ensemble de données utilisé dans l'application peut être téléchargé Ici . L'ensemble de données comprend 2 fichiers, deliveryies.csv contient des livraisons de score pour chaque balle (en plus) batteur, melon, détails des courses et matches.csv Le fichier contient les détails du match tels que le lieu du match, le tirage au sort, le lieu et les détails du match. L'application ci-dessous nécessite des connaissances de base sur déplyr et pour comprendre le didacticiel ci-dessous.

Suivez les étapes ci-dessous pour créer votre première application brillante.

Étape 1 : Créez le contour d'une application Shiny.

Effacez le code existant à l'exception des définitions de fonction dans le app . R fichier.

Étape 2 : Chargez les bibliothèques et les données.

Dans cette étape, nous chargeons les packages et les données requis. Ensuite, nettoyez et transformez les données extraites dans le format requis. Ajoutez le code ci-dessous avant OIGNON et serveur fonction.

Code:

library (shiny) library (tidyverse) # Chargement de l'ensemble de données --------------------------------------- ---------------- livraisons = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) matches = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Jeu de données de nettoyage --------------------------------------------- --------- noms (correspondances) [1] = 'match_id' IPL = dplyr :: inner_join (correspondances, livraisons)

Explication :

Les 2 premières lignes se chargent tidyverse et Brillant paquet. Les 2 lignes suivantes chargent les livraisons et les correspondances des ensembles de données et les stockent dans des variableslivraisonsetallumettes. Les 2 dernières lignes mettent à jour le nom de la colonne duallumettesensemble de données pour effectuer une jointure interne avec lelivraisonstable. Nous stockons le résultat de la jointure dans leIPLvariable.

Étape 3 : Créer la mise en page de l'application Shiny .

Comme indiqué précédemment, le OIGNON La fonction définit l'apparence, les widgets et les objets de l'application dans l'application Shiny.Discutons de la même chose en détail.

Code

oignon<- fluidPage( headerPanel('IPL - Indian Premier League'), tabsetPanel( tabPanel(title = 'Season', mainPanel(width = 12,align = 'center', selectInput('season_year','Select Season',choices=unique(sort(matches$season, decreasing=TRUE)), selected = 2019), submitButton('Go'), tags$h3('Players table'), div(style = 'border:1px black solidwidth:50%',tableOutput('player_table')) )), tabPanel( title = 'Team Wins & Points', mainPanel(width = 12,align = 'center', tags$h3('Team Wins & Points'), div(style = 'float:leftwidth:36%',plotOutput('wins_bar_plot')), div(style = 'float:rightwidth:64%',plotOutput('points_bar_plot')) ) )))

La OIGNON fonction contient un headerPanel () ou titlePanel () et suivi de tabsetPanel pour définir plusieurs onglets dans l'application. tabPanel () définit respectivement les objets pour chaque onglet. Chaque tabPanel () se compose du titre et Panneau principal(). Panneau principal() crée un conteneur de largeur 12, c'est-à-dire une fenêtre pleine et aligne les objets d'entrée et de sortie au centre.

Explication

L'application se compose de 2 onglets: Saison et L'équipe gagne et points.

Saison l'onglet se compose de selectInput ( ) , bouton d'envoi et un tableau. season_year est utilisé pour lire l'entrée du lest de valeurs. tableOutput () affiche la sortie de table calculée sur la fonction serveur.La table player_table est affichée sous le bouton qui est défini dans la fonction de serveur qui sera discutée à l'étape suivante. L'équipe gagne et points L'onglet affiche les gains et les points par équipe dans les graphiques à barres respectifs. plotOutput () affiche les sorties renvoyées par le rendu * les fonctions. Toutes les fonctions de sortie et d'entrée sont incluses dans une balise div pour ajouter un style en ligne.

Maintenant que nous sommes familiarisés avec la fonction d'interface utilisateur, allons-y avec la compréhension et l'utilisation de la fonction serveur dans notre didacticiel R Shiny.

Étape 4: ajoutez les instructions de fonction du serveur

La serveur fonction implique la création de fonctions et outputs qui utilisent des entrées utilisateur pour produire divers types de sortie. LaLa fonction du serveur est expliquée étape par étape ci-dessous.

matches_year = reactive ({matches%>% filter (season == input $ season_year)}) playoff = reactive ({nth (sort (matches_year () $ match_id, décroissant = TRUE), 4)}) matches_played = reactive ({matches_year ()%>% filter (match_id% group_by (team1)%>% summary (count = n ())}) t2 = reactive ({matches_played ()%>% group_by (team2)%>% summary (count = n ( ))}) wl = réactif ({matches_played ()%>% filtre (gagnant! = '')%>% group_by (gagnant)%>% résumer (no_of_wins = n ())}) wl1 = réactif ({matches_played ( )%>% group_by (gagnant)%>% résumer (no_of_wins = n ())}) égal = réactif ({matches_played ()%>% filtre (gagnant == '')%>% select (équipe1, équipe2)} ) playertable = reactive ({data.frame (Teams = t1 () $ team1, Joué = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })

Le code ci-dessus filtre les matchs joués avant les éliminatoires chaque année et stocke le résultat dans la variable matches_played.player_tableLa table contient des statistiques de match par équipe, c'est-à-dire jouées, victoires et points. Variablesmatches_played,player_table,t1,lié, etc. sont tous intermédiaires valeurs réactives . Ces variables doivent être accessibles en utilisant () comme indiqué dans le code ci-dessus.player_tables'affiche à l'aide de la fonction renderTable. Ensuite, créez la variable de sortie pour stocker la table de lecture.

sortie $ player_table = renderTable ({playertable ()})

Créons maintenant des graphiques à barres pour montrer les victoires et les points marqués par chaque équipe au cours de la saison. Le code ci-dessous affiche des graphiques à barres à l'aide de ggplot. renderPlot () récupère l'objet ggplot et stocke le résultat dans une variablewins_bar_plotLe code ggplot est explicite, il implique des graphiques de base et des fonctions de cartographie pour éditer la légende, les étiquettes et le tracé.

sortie $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (gagnant, no_of_wins, fill = gagnant)) + geom_bar (stat = 'identity') + theme_classic () + xlab ('Teams') + ylab ('Number Of Wins') + theme (axis.text.x = element_text (color = 'white'), legend.position = 'none', axis.title = element_text (size = 14), plot.background = element_rect (color = 'white')) + geom_text (aes (x = gagnant, (no_of_wins + 0.6), label = no_of_wins, size = 7))}) output $ points_bar_plot = renderPlot ({ggplot (playertable (), aes ( Teams, Points, fill = Teams)) + geom_bar (stat = 'identity', size = 3) + theme_classic () + theme (axis.text.x = element_text (color = 'white'), legend.text = element_text ( size = 14), axis.title = element_text (size = 14)) + geom_text (aes (Teams, (Points + 1), label = Points, size = 7))})

Étape 5: Exécutez l'application Shiny.

Cliquez sur Exécuter l'application. Avec une exécution réussie, votre application Shiny ressemblera à celle ci-dessous. Toute erreur ou avertissementliés à l'application, il les affichera dans R Console.

Tab1 - Saison

Tab2 - Victoires et points d'équipe

Voyons commentinstallerCompte Shinyapps.io pour déployer vos applications Shiny.

Configurer un compte Shinyapps.io

Aller à Shinyapps.io et connectez-vous avec vos informations, puis attribuez un nom de compte unique à la page et enregistrez-la. Une fois l'enregistrement réussi, vous verrez une procédure détaillée pour déployer des applications à partir de la console R. Suivez la procédure ci-dessous pour configurer votre compte dans Rstudio.

Étape 1. Installez rsconnect

install.packages ('rsconnect')

Étape 2. Autoriser le compte

La rconnecter package doit être autorisé sur votre compte à l'aide d'un jeton et d'un secret. Pour ce faire, copiez la commande entière comme indiqué ci-dessous dans votre page de tableau de bord dans R console. Une fois que vous avez entré la commande avec succès dans R, je vous autorise maintenant à déployer des applications sur votre compte Shinyapps.io.

rsconnect :: setAccountInfo (nom = 'nom du compte', jeton = 'jeton', secret = 'secret')

Étape 3. Déployer l'application

Utilisez le code ci-dessous pour déployer des applications Shiny.

bibliothèque (rsconnect) rsconnect :: deployApp ('chemin / vers / votre / application')

Une fois défini, vous êtes prêt à déployer vos applications brillantes.

qu'est-ce que sqoop dans hadoop

Maintenant que vous avez appris à créer et exécuter des applications Shiny, déployez l'application que nous venons de créer dans Shinyapps.io comme expliqué ci-dessus ou cliquez sur publier, qui est présent dans le coin supérieur droit de la fenêtre de l'application Shiny.

J'espèreque ce didacticiel R Shiny vous a aidé à apprendre à créer et à exécuter une application Shiny. Amusez-vous à créer de belles applications Web interactives à l'aide de R Shiny.

Si vous souhaitez apprendre la programmation R et construire une carrière colorée dans l'analyse des données, consultez notre qui vient avec une formation en direct animée par un instructeur et une expérience de projet réelle. Cette formation vous aidera à comprendre l'analyse des données et vous aidera à maîtriser le sujet.