Contents

What is a Web App?

Web Apps are packages of application software that run within a web browser rather than natively on the operating system of a device. They can be used to surface all kinds of information such as customer churn, stock levels or most efficient logistics routes.

You can either deploy a Genric Web App or Shiny Web App.

Once deployed, Web Apps appear within Work > Services section of the Peak platform.

What is Shiny?

Shiny is an R package that allows users to create interactive Web Apps.

Shiny Web Apps can also be supplemented with HTML, Javascript and CSS themes for additional functionality and customization.


Shiny Web App structure

Shiny Web Apps are built in two halves; the user interface (UI) and the server.


The UI

The UI contains everything the end user will see and interact with, this could contain but is not limited to:

  • Buttons

  • HTML widgets

  • Inputs (text, sliders, drop down)

  • Tabbed pages

  • Tables

  • Date visualizations


Example of code-building in a Shiny UI:

## Fill in the dashboard title

header <- dashboardHeader(title = "Training Dashboard")

############

#   Body   #

############

body <- dashboardBody(
  # Main body of the page
  # Page layout and UI items go here
  ## Fill in the body
  # use fluidRow() to create a new row
  # use column(width, ..., ), to create a new column
  fluidRow(
    column(12, 
           valueBoxOutput('countofrows')
           valueBoxOutput('mean_error'),
           valueBoxOutput('mean_percentage_error')
  )),
    column(6, plotOutput('avgbathrooms')),
    column(6, plotOutput('avgbedrooms')), 
    DTOutput('main_table')
)

ui <- dashboardPage(header, sidebar = dashboardSidebar(disable = TRUE), body)
 
```


Server

The server hosts the code that enables the interactivity for users through the UI.

The operations which the server could perform are limitless but could include:

  • Creating visualizations

  • Executing arbitrary code

  • Manipulating data inputs

  • Modeling data


Example of code building in a Shiny UI:

server <- function(input, output, session) {
 df = dbGetQuery(con, "select * from STAGE.HOUSEPRICES")
 df = df %>% 
   mutate( 
       error = PRICE - PREDICTIONS, 
    percentage_error = error /PRICE) 

  output$countofrows <- renderValueBox({
    rowcount = df %>% nrow()
    valueBox(paste0(rowcount / 1000, "k"), subtitle = 'Count of Rows')
    })

output$mean_error <- renderValueBox({
   mean_error = mean(df$error)
   valueBox(round(mean_error, 2), subtitle = 'Mean Error')
 })

output$mean_percentage_error <- renderValueBox({
  mean_percentage_error = mean(df$percentage_error)
 valueBox(sprintf("%0.1f%%", mean_percentage_error * 100), subtitle = 'Mean %  Error')
 })

  output$avgbathrooms <- renderPlot({
    df %>%
      mutate(bathrooms = as.character(round(bathrooms))) %>%
      group_by(bathrooms) %>%
      summarise(avg_price = mean(as.numeric(price))) %>%
      ggplot(aes(x = bathrooms, y = avg_price)) +
      geom_bar(stat = 'identity', fill = '#000033') +
      labs(x = 'Bathrooms', y = 'Average Price') +
      scale_y_continuous(labels = scales::comma) +
      theme(text = element_text(size = 20)) +
      theme_clean() 
  })

  output$avgbedrooms <- renderPlot({
    df %>%
      group_by(bedrooms) %>%
      summarise(avg_price = mean(as.numeric(price))) %>%
      ggplot(aes(x = as.character(bedrooms), y = avg_price)) +
      geom_bar(stat = 'identity', fill = '#000033') +
      labs(x = 'Bedrooms', y = 'Average Price') +
      scale_y_continuous(labels = scales::comma) +
      theme(text = element_text(size = 20))  +
      theme_clean() 
  })

  output$main_table =  renderDT(
    df, 
    options = list(scrollX = TRUE))
}

Running a Shiny Web App

Shiny Web Apps are really easy to launch.

All you need to do is execute this command:

shinyApp(ui, server)

For a deeper overview of Shiny, see their documentation.

What is Streamlit?

Streamlit is an open source app framework that uses the Python coding language. It allows users to create simple, custom-made Web Apps to visualize data science and machine learning work.

It works with major Python libraries, including:

  • Scikit-Learn

  • Keras

  • PyTorch

  • Sympy

  • Numpy

  • Pandas

  • Matplotlib

Streamlit is an alternative to using Shiny to create Web Apps.


Example app:

import streamlit as st

st.set_page_config(layout="wide")

st.title("Demo Dashboard")

df = <your_dataframe>

df['error'] = df['PRICE'] - df['PREDICTIONS']
df['perc_error'] = df['error'] / df['PRICE']

n_rows, mean_error, mean_percentage_error = st.columns(3)

n_rows.metric("Number of Rows", len(df))

mean_error.metric("Mean Error", round(df['error'].mean(), 2))

mean_percentage_error.metric("Mean Percentage Error", "{0:.0%}".format(df['perc_error'].mean()))

avg_bedroom_price, avg_bathroom_price = st.columns(2)

avg_bedroom_price.header("Average Bedroom Price")

avg_bedroom_price.bar_chart(

    pd.DataFrame(df.groupby('BEDROOMS')['PRICE'].mean()).reset_index()

)


avg_bathroom_price.header("Average Bathroom Price")

avg_bathroom_price.bar_chart(

    pd.DataFrame(df.groupby('BATHROOMS')['PRICE'].mean()).reset_index()

)

st.dataframe(
   df
)

For a deeper overview of Streamlit, see their documentation.


What is Dash?

Dash is an open source Python framework that is used for creating interactive Web Apps and is another alternative to Shiny.

Dash is written on top of Flask, Plotly.js and Reach.js. Dash does not require any knowledge of HTML, CSS and Javascript in order to create interactive dashboards, it only requires you to know how to write Python.

For a deeper overview of Dash, see their Github project.