R Glanzende zelfstudie: alles wat u moet weten



Deze R Shiny-zelfstudie biedt u een gedetailleerde en uitgebreide kennis van R Shiny en hoe u interactieve webtoepassingen kunt maken.

Met de evolutie van de technologie zijn er nieuwere tools en frameworks ontstaan ​​voor het bouwen van webapplicaties die real-time statistieken, kaarten en grafieken weergeven. Omdat deze functionaliteiten een hoge verwerking en synchronisatie vereisen, worden programmeertalen gebruikt om de laadtijd van de server te verminderen. In deze R Shiny-zelfstudie leg ik uit hoe u R optimaal kunt gebruiken in dynamische webapplicaties.

We behandelen en begrijpen de volgende onderwerpen:





Wat is R glanzend?

Shiny is een R-pakket waarmee gebruikers interactieve webapps kunnen bouwen. Deze tool maakt een HTML-equivalente web-app van Shiny-code. We integreren native HTML- en CSS-code met R Shiny-functies om de applicatie presentabel te maken. Shiny combineert de rekenkracht van R met de interactiviteit van het moderne web.Shiny maakt webapps die op internet worden geïmplementeerd met uw server of de hostingservices van R Shiny.

Eigenschappen van R Shiny:

  • Maak eenvoudige applicaties met basiskennis of zonder kennis van webtools
  • Integreer Shiny met native webtools om de flexibiliteit en productiviteit te verbeteren
  • Vooraf gebouwde I / O- en renderfuncties
  • Eenvoudige weergave van de applicatie-inhoud zonder meerdere herlaadbeurten
  • Functie om berekende (of verwerkte) uitvoer van R-scripts toe te voegen
  • Voeg live rapporten en visualisaties toe.

Dat brengt ons bij de vraag:



Waarin verschilt Shiny van traditionele toepassingen?

Laten we een voorbeeld nemen van een weertoepassing: telkens wanneer de gebruiker de pagina vernieuwt / laadt of invoer wijzigt, moet deze de hele pagina of een deel van de pagina bijwerken met JS. Dit voegt belasting toe aan de serverzijde voor verwerking. Met Shiny kan de gebruiker elementen in de app isoleren of renderen (of opnieuw laden), waardoor de serverbelasting wordt verminderd. Bladeren door pagina's was gemakkelijk in traditionele webapplicaties, maar was moeilijk met glanzende apps. De structuur van de code speelt de belangrijkste rol bij het begrijpen en debuggen van de code. Deze functie is cruciaal voor glanzende apps ten opzichte van andere applicaties.

Laten we naar het volgende onderwerp in de tutorial R Shiny gaan, het R Shiny-pakket installeren.

R Shiny installeren

Het installeren van Shiny is als het installeren van een ander pakket in R. Ga naar R-console en voer de onderstaande opdracht uit om het glanzende pakket te installeren.



install.packages ('glanzend')

Installeer R Shiny - R glanzende tutorial - Edureka

Nadat u het hebt geïnstalleerd, laadt u het glanzende pakket om glanzende apps te maken.

bibliotheek (glanzend)

Voordat we verder gaan in deze glanzende R-zelfstudie, laten we de structuur van een glanzende applicatie eens bekijken en begrijpen.

Structuur van een glanzende app

Glanzend bestaat uit 3 componenten:

  1. Gebruikersomgeving
  2. Server
  3. ShinyApp

een.Gebruikersinterface Functie

Gebruikersomgeving (UI) -functie bepaalt de lay-out en het uiterlijk van de app. U kunt CSS- en HTML-tags binnen de app toevoegen om de app presentabeler te maken. De functie bevat alle inputs en outputs die in de app moeten worden weergegeven. Elk element (divisie of tabblad of menu) in de app wordt gedefinieerd met behulp van functies. Deze zijn toegankelijk met een unieke id, zoals HTML-elementen.Laten we verder kijken naar verschillendefuncties die in de app worden gebruikt.

Glanzende lay-outfuncties

  • headerPanel ()voeg een kop toe aan de app. titlePanel () definieert de onderverdeling van de app. Zie de onderstaande afbeelding voor een beter begrip van headerPanel en titlePanel .
  • Indeling zijbalk ()definieert de lay-out die moet worden vastgehouden zijbalkPanel en hoofdpaneel elementen. De lay-out verdeelt het app-scherm in zijbalkpaneel en hoofdpaneel. In de onderstaande afbeelding is de rode rechthoek bijvoorbeeld de hoofdpaneel gebied en het zwarte rechthoekige gebied verticaal is zijbalkPanel Oppervlakte.

  • wellPanel ()definieert een container die meerdere objecten app invoer / uitvoer-objecten in hetzelfde raster bevat.
  • tabsetPanel ()maakt een container voor tabbladen. tabPanel () voegt tab toe aan de app door tabelementen en componenten te definiëren. In de onderstaande afbeelding is het zwartrechthoek is tabsetPanel object en de rode rechthoek is de tabPanel voorwerp.
  • navlistPanel ()biedt een zijmenu met links naar verschillende tabbladen, vergelijkbaar met tabsetPanel () zoals een verticale lijst aan de linkerkant van het scherm. In de onderstaande afbeelding is de zwarte rechthoek navlistPanel object en de rode rechthoek is de tabPanel voorwerp.

Naast glanzende lay-outfuncties kunt u ook inline CSS toevoegen aan elke invoerwidget in de app.De Shiny-app bevat functies van de webtechnologieën samen met glanzende R-functies en -functies om de app te verrijken. Gebruik HTML-tags in de Shiny-app met tags $.

Je lay-out is klaar, het is tijd om widgets aan de app toe te voegen. Shiny biedt verschillende gebruikersinvoer- en uitvoerelementen voor gebruikersinteractie. Laten we een paar invoer- en uitvoerfuncties bespreken.

Glanzende invoerfuncties

Elke invoerwidget heeft een label, Id, andere parameters zoals keuze, waarde, geselecteerd, min, max, etc.

  • selectInput ()- maak een dropdown HTML-element.
selectInput ('select', h3 ('Select box'), keuzes = lijst ('Choice 1' = 1, 'Choice 2' = 2, 'Choice 3' = 3), selected = 1)

  • numerieke invoer ()- invoergebied om een ​​nummer of tekst te typen.
dateInput ('num', 'Date input', value = '2014-01-01') numericInput ('num', 'Numeric input', value = 1) textInput ('num', 'Numeric input', value = ' Tekst invoeren...')

  • Radio knoppen()- maak keuzerondjes voor gebruikersinvoer.
radioButtons ('radio', h3 ('Radioknoppen'), keuzes = lijst ('Keuze 1' = 1, 'Keuze 2' = 2, 'Keuze 3' = 3), geselecteerd = 1)

Glanzende uitvoerfuncties

Shiny biedt verschillende uitvoerfuncties die worden weergegeven R uitgangen zoals plots, afbeeldingen, tabellen, enz. die corresponderende R voorwerp.

  • plotOutput ()- R-plotobject weergeven.
plotOutput'top_batsman ')
  • tableOutput ()- geeft de uitvoer weer als tabel.
tableOutput'player_table ')

2. Serverfunctie

Server functie ddefinieert de server-side logica van de Shiny-app. Het omvat het creëren van functies en outputs die inputs gebruiken om verschillende soorten output te produceren. Elke client (webbrowser) roept de serverfunctie op wanneer deze de Shiny-app voor het eerst laadt. Elke uitvoer slaat de geretourneerde waarde van de renderfuncties op.

Deze functies vangen een R-uitdrukking op en doen berekeningen en voorbewerkingen op de uitdrukking. Gebruik de render * -functie die overeenkomt met de uitvoer die u definieert. We hebben toegang tot invoerwidgetsgebruik makend van voer $ [widget-id] in . Deze invoervariabelen zijn reactieve waarden. Eventuele tussenliggende variabelen die zijn gemaakt met behulp van invoervariabelen, moeten reactief worden gemaakt met reactief ({}) . Open de variabelen met ().

render * functies voeren de berekening uit binnen de serverfunctie en slaan deze op in de uitvoervariabelen. De output moet worden opgeslagen met output $ [naam uitvoervariabele] . Elk render * functie heeft een enkel argument, d.w.z. een R-uitdrukking omgeven door accolades, {}.

3. ShinyApp-functie

shinyApp ()functie is het hart vande app die belt UI en server functies om een ​​glanzende app te maken.

De onderstaande afbeelding toont de omtrek van de Shiny-app.

Laten we naar het volgende segment in de R Shiny-zelfstudie gaan om de eerste R Shiny-app te maken.

Maak een glanzend webproject

Ga naar het dossier en maak een Nieuw project in een willekeurige directory -> Glanzende webapplicatie -> [Naam van glanzende toepassingsmap]. Voer de naam van de directory in en klik op OK .

Elk nieuw Shiny-app-project bevat een histogramvoorbeeld om de basisprincipes van een glanzende app te begrijpen. De histogram-app bevat een schuifregelaar gevolgd door een histogram dat de uitvoer bijwerkt voor een wijziging in de schuifregelaar. Hieronder ziet u de uitvoer van de histogram-app.

Om de Shiny-app uit te voeren, klikt u op het Voer de app uit knop in de rechterbovenhoek van het bronvenster. De Shiny-app geeft een schuifregelaar-widget weer die het aantal bakken als invoer neemt en het histogram weergeeft op basis van de invoer.

Nu je de structuur hebt begrepen en hoe je een Shiny-app moet draaien. Laten we verder gaan met het maken van onze eerste glanzende app.

Maak de eerste glanzende app

U kunt een nieuw project maken of doorgaan in dezelfde werkdirectory. In deze R Shiny-zelfstudie maken we een eenvoudige Shiny-app om IPL-statistieken weer te geven. De dataset die in de app wordt gebruikt, kan worden gedownload hier . De dataset bestaat uit 2 bestanden, leveringen.csv bevat score-leveringen voor elke bal (in over) batsman, bowler, runs details en wedstrijden.csv bestand bevat wedstrijddetails zoals wedstrijdlocatie, toss, locatie en speldetails. De onderstaande app vereist basiskennis van dplyr en om de onderstaande tutorial te begrijpen.

Volg de onderstaande stappen om uw eerste glanzende app te maken.

Stap 1 : Maak de omtrek van een glanzende app.

Wis de bestaande code behalve de functiedefinities in het app . R het dossier.

c ++ sorteer nummers in oplopende volgorde

Stap 2 : Laad bibliotheken en gegevens.

In deze stap laden we de vereiste pakketten en gegevens. Maak vervolgens de geëxtraheerde gegevens schoon en transformeer ze in het vereiste formaat. Voeg de onderstaande code eerder toe UI en server functie.

Code:

bibliotheek (glanzend) bibliotheek (tidyverse) # Dataset laden --------------------------------------- ---------------- deliveries = read.csv ('C: UsersCherukuri_SindhuDownloadsdeliveries.csv', stringsAsFactors = FALSE) matches = read.csv ('C: UsersCherukuri_SindhuDownloadsmatches.csv', stringsAsFactors = FALSE) # Dataset opschonen --------------------------------------------- --------- namen (overeenkomsten) [1] = 'match_id' IPL = dplyr :: inner_join (overeenkomsten, leveringen)

Uitleg :

De eerste 2 regels worden geladen tidyverse en Glimmend pakket. De volgende 2 regels laden datasets leveringen en overeenkomsten en slaan op in variabelenleveringenenwedstrijden. De laatste 2 regels werken de kolomnaam van hetwedstrijdendataset om een ​​innerlijke join uit te voeren met deleveringentafel. We slaan het join-resultaat op in hetIPLvariabele.

Stap 3 : Maak de lay-out van de glanzende app .

Zoals eerder besproken, is de UI functie definieert het uiterlijk, de widgets en de objecten van de app in de Shiny-app.Laten we hetzelfde in detail bespreken.

Code

ui<- 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')) ) )))

De UI functie bevat een headerPanel () of titlePanel () en gevolgd door tabsetPanel om meerdere tabbladen in de app te definiëren. tabPanel () definieert respectievelijk de objecten voor elk tabblad. Elk tabPanel () bestaat uit titel en hoofdpaneel(). hoofdpaneel() creëert een container met een breedte van 12, dat wil zeggen een volledig venster, en lijn invoer- en uitvoerobjecten in het midden uit.

Uitleg

De app bestaat uit 2 tabbladen: Seizoen en Team wint en punten.

Seizoen tabblad bestaat uit selectInput ( ) , verzendknop en een tafel. season_year wordt gebruikt om invoer van de l te lezenis van waarden. tableOutput () toont tabeluitvoer berekend op serverfunctie.Table player_table wordt weergegeven onder de knop die is gedefinieerd in de serverfunctie die in de volgende stap zal worden besproken. Team wint en punten tabblad toont teamgewijze winst en punten in de respectievelijke staafdiagrammen. plotOutput () geeft de uitvoer weer die is geretourneerd van render * functies. Alle uitvoer- en invoerfuncties zijn ingesloten in een div-tag om inline-stijl toe te voegen.

Nu we bekend zijn met de ui-functie, gaan we door met het begrijpen en gebruiken van de serverfunctie in onze R Shiny-zelfstudie.

Stap 4: Voeg de serverfunctie-instructies toe

De server functie omvat het creëren van functies en outputs die gebruikersinvoer gebruiken om verschillende soorten uitvoer te produceren. Dede serverfunctie wordt hieronder stap voor stap uitgelegd.

matches_year = reactief ({matches%>% filter (season == input $ season_year)}) playoff = reactive ({nth (sort (matches_year () $ match_id, afnemende = TRUE), 4)}) matches_played = reactief ({matches_year ()%>% filter (match_id% group_by (team1)%>% summarize (count = n ())}) t2 = reactief ({matches_played ()%>% group_by (team2)%>% summarize (count = n ( ))}) wl = reactief ({matches_played ()%>% filter (winner! = '')%>% group_by (winnaar)%>% summarize (no_of_wins = n ())}) wl1 = reactief ({matches_played ( )%>% group_by (winnaar)%>% summarize (no_of_wins = n ())}) gebonden = reactief ({matches_played ()%>% filter (winnaar == '')%>% select (team1, team2)} ) playertable = reactive ({data.frame (Teams = t1 () $ team1, Played = t1 () $ count + t2 () $ count, Wins = wl () $ no_of_wins, Points = wl () $ no_of_wins * 2) })

De bovenstaande codefiltermatches die elk jaar vóór de play-offs worden gespeeld, en het resultaat opslaan in de variabele matches_played.player_tabletabel bevat teamgewijze wedstrijdstatistieken, d.w.z. gespeeld, overwinningen en punten. Variabelenmatches_played,player_table,t1,gebonden, enz. zijn allemaal gemiddeld reactieve waarden . Deze variabelen moeten worden benaderd met (), zoals weergegeven in de bovenstaande code.player_tablewordt weergegeven met de functie renderTable. Maak vervolgens de uitvoervariabele om playertable op te slaan.

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

Laten we nu staafdiagrammen maken om overwinningen en gescoorde punten van elk team in het seizoen weer te geven. De onderstaande code geeft staafdiagrammen weer met ggplot. renderPlot () haalt het ggplot-object op en slaat het resultaat op in een variabelewins_bar_plotDe ggplot-code spreekt voor zich, het omvat basisafbeeldingen en kaartfuncties om legenda, labels en plot te bewerken.

output $ wins_bar_plot = renderPlot ({ggplot (wl1 () [2: 9,], aes (winnaar, no_of_wins, fill = winnaar)) + geom_bar (stat = 'identiteit') + 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 = winnaar, (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))})

Stap 5: voer de glanzende app uit.

Klik op App uitvoeren. Met een succesvolle run ziet uw Shiny-app eruit zoals hieronder. Elke fout of waarschuwings gerelateerd aan de app, worden deze weergegeven in R Console.

Tab1 - Seizoen

Tab2 - Teamoverwinningen en punten

Laten we eens kijken hoeopzettenShinyapps.io-account om uw Shiny-apps te implementeren.

Stel Shinyapps.io-account in

Ga naar Shinyapps.io en log in met uw gegevens, geef vervolgens een unieke accountnaam voor de pagina en sla deze op. Nadat het opslaan is gelukt, ziet u een gedetailleerde procedure om apps vanuit de R-console te implementeren. Volg de onderstaande procedure om uw account in Rstudio te configureren.

Stap 1. Installeer rsconnect

install.packages ('rsconnect')

Stap 2. Account autoriseren

De rsconnect pakket moet geautoriseerd zijn voor uw account met een token en geheim. Kopieer hiervoor de hele opdracht zoals hieronder weergegeven op uw dashboardpagina in R troosten. Nadat je de opdracht met succes hebt ingevoerd in R, machtig ik je nu om applicaties te implementeren op je Shinyapps.io-account.

rsconnect :: setAccountInfo (naam = 'accountnaam', token = 'token', secret = 'geheim')

Stap 3. App implementeren

Gebruik de onderstaande code om glanzende apps te implementeren.

bibliotheek (rsconnect) rsconnect :: deployApp ('pad / naar / jouw / app')

Eenmaal ingesteld, bent u klaar om uw glanzende apps te implementeren.

Nu je hebt geleerd hoe je Shiny-apps maakt en uitvoert, implementeer je de app die we zojuist hebben gemaakt in Shinyapps.io zoals hierboven uitgelegd of klik je op publiceren, die aanwezig is in de rechterbovenhoek van het glanzende app-venster.

ik hoopdat deze R Shiny-zelfstudie je heeft geholpen bij het leren maken en uitvoeren van een Shiny-app. Veel plezier met het maken van interactieve en prachtige webapps met R Shiny.

Als je R Programming wilt leren en een kleurrijke carrière in Data Analytics wilt opbouwen, bekijk dan onze die wordt geleverd met live training onder leiding van een instructeur en real-life projectervaring. Deze training helpt je data-analyse te begrijpen en je te helpen het onderwerp onder de knie te krijgen.