Lesson 1: Intro to plotting data in R with ggplot

 

Functions for Lesson 1
?, str, glimpse, summary, table, min, max, ggplot, geom_point, geom_smooth, theme_minimal, theme_classic, theme_tufte
 

Packages for Lesson 1
tidyverse, ggplot2, dplyr
 

Agenda

Data visualisation in R for Data Science, Section 3.1.1.

  • Intro to the Renvironment (IDE)
  • Loading packages, e.g. tidyverse
  • Using built-in R data: the mpg dataset
  • Using ggplot with the built-in data set (to make scatterplots)
  • Modifying plot aesthetics
  • Reading in outside data: Airbnb data
  • Plotting Airbnb data with ggplot

 

Intro to the R environment (IDE)

The RStudio integrated development environment (IDE) and what you can do with it.
 

 

A more complete example of what you can acheive with the interface.
 

 

Loading packages, e.g. tidyverse

How to load packages in R.

install.packages("tidyverse")  # install package
library(tidyverse)  # load the package library
require(tidyverse)  # same as library    

# We are typing in an R Script. Things with # in front make them comments and notes to ourselves
# Command Return to execute the line/ 'run the code'

 

Using built-in R data: the mpg dataset

Section 3.2.1

We'll use a built-in tidyverse dataset called mpg with data about cars and gas-mileage.

mpg
# run help page with '?'
`?`(mpg)
  • This is a tibble (data frame) that we've "printed" out. It's like R's version of an excel spreadsheet, but much better.
  • A tibble will show us the first 10 rows, rows containing the data, column names, and the class of data within each column, such as numeric, integer, or character.

Summarising data

str(mpg)  # structure of data
glimpse(mpg)  # preview of data 
summary(mpg)  # basic summary stats  
table(mpg$manufacturer)  # counts of each column
head(mpg)  # visualise first 6 rows of data
tail(mpg, 10)  # visualise last 10 (or N) rows of data 
names(mpg)  # get column names
class(mpg)  # class of data frame
class(mpg$manufacturer)  # class of data column
mpg$displ  # print a column
mpg$hwy  # print a column

 

Creating a plot with ggplot

Section 3.2.2

  • ggplot() Creates a coordinate system for us--basically an empty graph.
  • geom_point() Adds a "layer", e.g. geom_point (but there are many for different kinds of graphs).

Plot two of the data columns

ggplot(data = mpg) + geom_point(mapping = aes(x = displ, y = hwy))

 

Changing the data column inputs for the x and y axis of the plot

ggplot(data = mpg) + geom_point(mapping = aes(x = class, y = drv))

 

Assign data to variables to create dynamic inputs

my_data <- mpg  # create own variable using a name of your choice  

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy))

 

Themes

Change plot style. Link for more ggplot themes.

require(ggthemes)

# classic theme
ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy)) + theme_minimal()

# minimal theme
ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy)) + theme_tufte()

# assign theme to variable
my_theme <- theme_classic()
ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy)) + my_theme  # apply your chosen theme  

 

Aesthetic mapping

Section 3.3

colour. Change the colour of the data points. size. Change the size of the data points.
alpha. Change the transparency of the data points.

Colour

Colour by colour name.

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy), colour = "light blue") + my_theme

 

Colour by a hex code in quotes.

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy), colour = "#BB5C42") + my_theme

 

colour by data column

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, colour = class)) + my_theme

 

Inside versus outside the aes

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, colour = "blue")) + my_theme

 

Size

Size by integer

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, size = 5)) + my_theme

 

Size by data column

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, size = class)) + my_theme

 

We get a warning, but this is okay.
 

Transparency

# map classe column to different transparencies
ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, alpha = class)) + my_theme

 

Shape

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, shape = class)) + my_theme

 

Any warnings? Yes, because shape maxes out at six levels.  

Manually changing aesthetic properties

But we can set the aesthetic properties manually, instead of having ggplot do the scaling automatically. For example, we can make our ggplot points all blue like this. This time, putting colour OUTSIDE the aes argument.

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy), colour = "blue") + my_theme

 

Using colour both inside and outside the aes

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, colour = class), colour = "#AE42BB") + 
    my_theme

 

The inner one is overridden.
 

Putting it all together as a snapshot of what's possible

ggplot(data = my_data) + geom_point(mapping = aes(x = displ, y = hwy, colour = class, size = class, alpha = class)) + 
    my_theme

Aesthetics you can manually set

  • The name of a colour as a character string.
  • The size of a point in mm.
  • The shape of a point as a number, as shown in Figure 3.1.

 

R has 25 built in shapes that are identified by numbers. There are some seeming duplicates: for example, 0, 15, and 22 are all squares. The difference comes from the interaction of the colour and fill aesthetics. The hollow shapes (0--14) have a border determined by colour; the solid shapes (15--18) are filled with colour; the filled shapes (21--24) have a border of colour and are filled with fill.

Further plotting examples

Section 3.3.1

The online reference contains further examples of how to visualise your data.

Reading in outside data: NYC Airbnb data

# A tibble: 6 x 74
     id listing_url  scrape_id last_scraped name   description  neighborhood_ov… picture_url host_id
  <dbl> <chr>            <dbl> <date>       <chr>  <chr>        <chr>            <chr>         <dbl>
1  2595 https://www…   2.02e13 2021-04-09   Skyli… "Beautiful,… Centrally locat… https://a0…    2845
2  3831 https://www…   2.02e13 2021-04-12   Whole… "Enjoy 500 … Just the right … https://a0…    4869
3  5121 https://www…   2.02e13 2021-04-09   Bliss… "<b>The spa… <NA>             https://a0…    7356
4  5136 https://www…   2.02e13 2021-04-10   Spaci… "We welcome… <NA>             https://a0…    7378
5  5178 https://www…   2.02e13 2021-04-12   Large… "Please don… Theater distric… https://a0…    8967
6  5203 https://www…   2.02e13 2021-04-09   Cozy … "Our best g… Our neighborhoo… https://a0…    7490
# … with 65 more variables: host_url <chr>, host_name <chr>, host_since <date>,
#   host_location <chr>, host_about <chr>, host_response_time <chr>, host_response_rate <chr>,
#   host_acceptance_rate <chr>, host_is_superhost <lgl>, host_thumbnail_url <chr>,
#   host_picture_url <chr>, host_neighbourhood <chr>, host_listings_count <dbl>,
#   host_total_listings_count <dbl>, host_verifications <chr>, host_has_profile_pic <lgl>,
#   host_identity_verified <lgl>, neighbourhood <chr>, neighbourhood_cleansed <chr>,
#   neighbourhood_group_cleansed <chr>, latitude <dbl>, longitude <dbl>, property_type <chr>,
#   room_type <chr>, accommodates <dbl>, bathrooms <lgl>, bathrooms_text <chr>, bedrooms <dbl>,
#   beds <dbl>, amenities <chr>, price <chr>, minimum_nights <dbl>, maximum_nights <dbl>,
#   minimum_minimum_nights <dbl>, maximum_minimum_nights <dbl>, minimum_maximum_nights <dbl>,
#   maximum_maximum_nights <dbl>, minimum_nights_avg_ntm <dbl>, maximum_nights_avg_ntm <dbl>,
#   calendar_updated <lgl>, has_availability <lgl>, availability_30 <dbl>, availability_60 <dbl>,
#   availability_90 <dbl>, availability_365 <dbl>, calendar_last_scraped <date>,
#   number_of_reviews <dbl>, number_of_reviews_ltm <dbl>, number_of_reviews_l30d <dbl>,
#   first_review <date>, last_review <date>, review_scores_rating <dbl>,
#   review_scores_accuracy <dbl>, review_scores_cleanliness <dbl>, review_scores_checkin <dbl>,
#   review_scores_communication <dbl>, review_scores_location <dbl>, review_scores_value <dbl>,
#   license <lgl>, instant_bookable <lgl>, calculated_host_listings_count <dbl>,
#   calculated_host_listings_count_entire_homes <dbl>,
#   calculated_host_listings_count_private_rooms <dbl>,
#   calculated_host_listings_count_shared_rooms <dbl>, reviews_per_month <dbl>

 

Using a smaller dataset

# smaller csv file (16 cols)
url <- "http://data.insideairbnb.com/united-states/ny/new-york-city/2021-04-07/data/listings.csv.gz"

nyc <- read_csv(url)
nyc <- nyc[nyc$id < 20000, ]  # get smaller subet of data
length(nyc$id)  # print length of 'id' column
head(nyc)

 

Plotting AirBnB data with ggplot

Using the above plotting functions to visualise the AirBnB data

# plot neighborhood_group vs price
ggplot(data = nyc) + geom_point(mapping = aes(x = neighbourhood_group_cleansed, y = price, colour = neighbourhood_group_cleansed), 
    shape = 21, stroke = 1) + my_theme

# plot minimum_nights vs price
ggplot(data = nyc) + geom_point(mapping = aes(x = minimum_nights, y = price, colour = neighbourhood_group_cleansed), 
    shape = 20, size = 3, stroke = 1) + my_theme

# availability_365 vs price
ggplot(data = nyc) + geom_point(mapping = aes(x = availability_365, y = price, colour = neighbourhood_group_cleansed), 
    shape = 21, stroke = 1) + my_theme

# plot longitude vs price
ggplot(data = nyc) + geom_point(mapping = aes(x = longitude, y = price, colour = neighbourhood_group_cleansed), 
    shape = 21, stroke = 1) + my_theme

Try your own plot using the other variables in the dataset

# plot neighborhood_group vs price
names(airbnb)
glimpse(airbnb)

my_data <- NULL
x <- NULL
y <- NULL
colour <- NULL
shape <- NULL
stroke <- NULL
---
params:
  lesson: "Lesson 1"
  title: "Intro to plotting data in R with `ggplot`"
  bookchapter_name: "Section 3.1.1"    
  bookchapter_section: "https://r4ds.had.co.nz/data-visualisation.html"
  functions: "`?`, `str`, `glimpse`, `summary`, `table`, `min`, `max`, `ggplot`, `geom_point`, `geom_smooth`, `theme_minimal`, `theme_classic`, `theme_tufte`"
  packages: "`tidyverse`, `ggplot2`, `dplyr`"      
  # end inputs ---------------------------------------------------------------
header-includes: \usepackage{float}
always_allow_html: yes
output:
  html_document:
    code_folding: show
    code_download: true
---
  
```{r, setup, echo = FALSE, cache = FALSE, include = FALSE}
options(width=100)
knitr::opts_chunk$set(
  eval = FALSE, # run all code
  echo = TRUE, # show code chunks in output 
  tidy = TRUE, # make output as tidy
  message = FALSE,  # mask all messages
  warning = FALSE, # mask all warnings 
  comment = "",
  tidy.opts=list(width.cutoff=100), # set width of code chunks in output
  size="small" # set code chunk size
  )
```
\

<!-- install packages -->
```{r, load packages, eval=T, include=T, cache=F, message=F, warning=F, results='hide',echo=F}
packages <- c("ggplot2","ggthemes","dplyr","tidyverse","zoo","RColorBrewer","viridis","plyr")   
if (require(packages)) {
    install.packages(packages,dependencies = T)
    require(packages)
    # load tvthemes
    # devtools::install_github("Ryo-N7/tvthemes")
}
lapply(packages,library,character.only=T)  
```

<!-- ____________________________________________________________________________ -->
<!-- ____________________________________________________________________________ -->
<!-- ____________________________________________________________________________ -->
<!-- start body -->

# `r paste0(params$lesson,": ",params$title)`    
\  

Functions for `r params$lesson`  
`r params$functions`    
\    

Packages for `r params$lesson`          
`r params$packages`        
\    

# Agenda  

[Data visualisation in `R` for Data Science, `r params$bookchapter_name`](`r params$bookchapter_section`).    

<!--  end yaml template------------------------------------------------------- -->

* Intro to the `R`environment (IDE)  
* Loading packages, e.g. `tidyverse`  
* Using built-in `R` data: the `mpg` dataset   
* Using ggplot with the built-in data set (to make scatterplots)    
* Modifying plot aesthetics  
* Reading in outside data: Airbnb data  
* Plotting Airbnb data with ggplot      

\  

# Intro to the `R` environment (IDE)  

The `RStudio` integrated development environment (IDE) and what you can do with it.  
\    

<!-- ----------------------- image --------------------------- -->
<div align="center">
  <img src="img/rstudio1.jpg" style=width:100%>
</div>
<!-- ----------------------- image --------------------------- -->
\  

A more complete example of what you can acheive with the interface.  
\  

<!-- ----------------------- image --------------------------- -->
<div align="center">
  <img src="img/rstudio2.jpg" style=width:100%>
</div>
<!-- ----------------------- image --------------------------- -->
\  

# Loading packages, e.g. `tidyverse`  

How to load packages in `R`.  

```{r}
install.packages("tidyverse")  # install package
library(tidyverse) # load the package library
require(tidyverse) # same as library    

# We are typing in an R Script. Things with # in front make them comments and notes to ourselves
# Command Return to execute the line/ "run the code"
```
\  

# Using built-in `R` data: the `mpg` dataset   
[Section 3.2.1](https://r4ds.had.co.nz/data-visualisation.html#the-mpg-data-frame)  

We'll use a built-in tidyverse dataset called `mpg` with data about cars and gas-mileage.

```{r}
mpg
# run help page with '?'
?mpg   
```

* This is a tibble (data frame) that we've "printed" out. It's like R's version of an excel spreadsheet, but much better. 
* A tibble will show us the first 10 rows, rows containing the data, column names, and the class of data within each column, such as numeric, integer, or character.    

## Summarising data        
```{r}
str(mpg) # structure of data
glimpse(mpg) # preview of data 
summary(mpg) # basic summary stats  
table(mpg$manufacturer) # counts of each column
head(mpg) # visualise first 6 rows of data
tail(mpg,10) # visualise last 10 (or N) rows of data 
names(mpg) # get column names
class(mpg) # class of data frame
class(mpg$manufacturer) # class of data column
mpg$displ # print a column
mpg$hwy # print a column
```
\    

# Creating a plot with `ggplot`  
[Section 3.2.2](https://r4ds.had.co.nz/data-visualisation.html#creating-a-ggplot)     

* `ggplot()` Creates a coordinate system for us--basically an empty graph.  
* `geom_point()` Adds a "layer", e.g. geom_point (but there are many for different kinds of graphs).  

Plot two of the data columns  
```{r, eval = T}
ggplot(data = mpg) + 
  geom_point(mapping = aes(x = displ, y = hwy))
```
\  

Changing the data column inputs for the **x** and **y** axis of the plot  
```{r, eval = T}
ggplot(data = mpg) + 
  geom_point(mapping = aes(x = class, y = drv))
```
\  

Assign data to variables to create dynamic inputs  
```{r, eval = T}
my_data <- mpg # create own variable using a name of your choice  

ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy))
```
\  

## Themes  

Change plot style. Link for more [ggplot themes](https://www.datanovia.com/en/blog/ggplot-themes-gallery/).        
```{r, eval = T}
require(ggthemes)

# classic theme
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy)) + 
  theme_minimal()

# minimal theme
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy)) + 
  theme_tufte()  

# assign theme to variable  
my_theme <- theme_classic() 
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy)) + 
  my_theme # apply your chosen theme  

```
\  

# Aesthetic mapping  
[Section 3.3](https://r4ds.had.co.nz/data-visualisation.html#aesthetic-mappings)  

`colour`. Change the colour of the data points.
`size`. Change the size of the data points.  
`alpha`. Change the transparency of the data points.   

## Colour

Colour by colour name. 
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy), colour = "light blue") +
  my_theme
  
```
\   

Colour by a [hex code](https://htmlcolorcodes.com/color-picker/) in quotes.  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy), colour = "#BB5C42") +
  my_theme
```
\  

colour by data column  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, colour = class)) +
  my_theme
```
\  

Inside versus outside the `aes`  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, colour = "blue")) +
  my_theme
```
\  

## Size 

Size by integer  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, size = 5)) +
  my_theme
```
\  

Size by data column      
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, size = class)) +
  my_theme
```
\  

We get a warning, but this is okay.  
\  

## Transparency 
```{r, eval = T}
# map classe column to different transparencies
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, alpha = class)) + 
  my_theme
```
\  

## Shape  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, shape = class)) +
  my_theme
```
\  

Any warnings? Yes, because shape maxes out at six levels.
\  

## Manually changing aesthetic properties
  
But we can *set* the aesthetic properties manually, instead of having ggplot do the scaling automatically. For example, we can make our ggplot points all blue like this. This time, putting colour OUTSIDE the `aes` argument.

```{r, eval = T}
ggplot(data = my_data) +  
  geom_point(mapping = aes(x = displ, y = hwy), colour = "blue") +
  my_theme
```
\  

Using colour both inside and outside the aes  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, colour = class), colour = "#AE42BB") +
  my_theme
```
\  

**The inner one is overridden.**     
\  

Putting it all together as a snapshot of what's possible  
```{r, eval = T}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = displ, y = hwy, colour = class, size = class, alpha = class)) +
  my_theme
```

## Aesthetics you can manually set  

  * The name of a colour as a character string.
  * The size of a point in mm.
  * The shape of a point as a number, as shown in Figure 3.1. 
  
  <!-- ----------------------- image --------------------------- -->
<div align="center">
  <img src="img/shapes.png" style=width:100%>
</div>
<!-- ----------------------- image --------------------------- -->
\  
  
`R` has 25 built in shapes that are identified by numbers. There are some seeming duplicates: for example, 0, 15, and 22 are all squares. The difference comes from the interaction of the `colour` and `fill` aesthetics. The hollow shapes (0--14) have a border determined by `colour`; the solid shapes (15--18) are filled with `colour`; the filled shapes (21--24) have a border of `colour` and are filled with `fill`.  

\newpage      

# Further plotting examples    
[Section 3.3.1](https://r4ds.had.co.nz/data-visualisation.html#exercises-1)  

The online reference contains further examples of how to visualise your data.    

# Reading in outside data: NYC Airbnb data  

```{r, eval = T, echo = F}
library(tidyverse) # includes package "readr"
# All Airbnb data (106 cols)
url <- "http://data.insideairbnb.com/united-states/ny/new-york-city/2021-04-07/data/listings.csv.gz"

nyc_full <- read_csv(url) # reads in data
head(nyc_full)
```
\  

Using a smaller dataset 
```{r, eval = T, results="hide"}
# smaller csv file (16 cols)
url <- "http://data.insideairbnb.com/united-states/ny/new-york-city/2021-04-07/data/listings.csv.gz"

nyc <-  read_csv(url)
nyc <- nyc[nyc$id < 20000,] # get smaller subet of data
length(nyc$id) # print length of 'id' column
head(nyc)
``` 
\    

# Plotting AirBnB data with ggplot  

Using the above plotting functions to visualise the AirBnB data  

```{r, eval = T}
# plot neighborhood_group vs price
ggplot(data = nyc) + 
  geom_point(mapping = aes(x = neighbourhood_group_cleansed, y = price, colour =
                             neighbourhood_group_cleansed), shape = 21, stroke = 1) +
  my_theme
```

```{r, eval=T}
# plot minimum_nights vs price
ggplot(data = nyc) + 
  geom_point(mapping = aes(x = minimum_nights, y = price, 
                           colour = neighbourhood_group_cleansed), shape = 20, size = 3, stroke = 1) +
  my_theme
```

```{r, eval=T}
# availability_365 vs price
ggplot(data = nyc) + 
  geom_point(mapping = aes(x = availability_365, y = price, 
                           colour = neighbourhood_group_cleansed), shape = 21, stroke = 1) +
  my_theme
```
    
```{r, eval=T}
# plot longitude vs price
ggplot(data = nyc) + 
  geom_point(mapping = aes(x = longitude, y = price, 
                           colour = neighbourhood_group_cleansed), shape = 21, stroke = 1) +
  my_theme
```


Try your own plot using the other variables in the dataset    
```{r}
# plot neighborhood_group vs price
names(airbnb)
glimpse(airbnb)

my_data <- NULL
x <- NULL
y <- NULL
colour <- NULL
shape <- NULL
stroke <- NULL
```

```{r, echo=F}
ggplot(data = my_data) + 
  geom_point(mapping = aes(x = x, y = y, colour = colour), shape = shape, stroke = stroke)
```

<!-- end body -->
<!-- ____________________________________________________________________________ -->
<!-- ____________________________________________________________________________ -->
<!-- ____________________________________________________________________________ -->

   
