The Goal

We are going to be using R extensively in this course. Because of this, our lab today is designed to remind us of some of the codes that we will be using frequently, including coding for data visualization. Most of the coding should feel familiar.

We will also practice some of the vocabulary terms we covered in our first class. These terms will be used throughout the semester, so let’s take some time to practice them now!

Note: This lab assumes that you have already installed the software and gone through the RMarkdown tutorial. If you have not done so, make sure to do these before starting the lab.

Loading the Data

Once we have opened up an RMarkdown file, the first thing we need to do is load the data. We will access data from a variety of sources in this course, but today we will be loading data from inside an R package. A package is a collection of codes that relate to one another. When you load a package into R, you give R access to all of the functions within the package.This means that our first step is to remind ourselves how to install an R package.

To install a package:

• 1. Look at the top of your RStudio screen and find “Tools”.
• 2. From the drop down menu, choose “Install Packages”.
• 3. In the white box, type palmerpenguins, and then hit install.

Now that we have the package installed, it is time to actually get the data from that package. To do that, we need to create a space in our RMarkdown file to create code. Remember, Markdown can do three things: (1) create regular text, (2) run code, and (3) create math equations. Right now, we want (2).

To tell RMarkdown we are about to give it code, we need to create a code chunk, or chunk for short. Look at the top of your Markdown file, and find Insert. Click it. From the drop-down menu, choose R. Click it! A gray box should appear in your Markdown file. This is a chunk.

Anything we put inside a chunk will be treated as computer code. Let’s put in a code to load the data now.

suppressMessages(library(palmerpenguins))
data("penguins")

Now, look at the right hand side of the chunk and find the little green triangle symbol. We will call this the play button in this course. Go ahead and press the play button (press play).

And that’s it! The data is now loaded and ready to use.

The Data

Our data set for today contains information on n = 344 penguins from three different species. We have a client who is interested in building a model for Y = the body mass of a penguin in grams.

So, there’s 3 vocab terms already:

• 1. Supervised Learning
• 2. Classification Task
• 3. Regression Task

Starting next week, there will be a list of vocabulary terms on Canvas to show which terms we have covered so far. Hopefully, this will be helpful for studying!

In addition to the response variable, the data set contains information on 7 features:

Now, we could use one model to try and suit the needs of both clients, or we could build two separate models, one designed for each task. As statisticians, it is our job to determine what is appropriate, and what is possible with our resources. More on that later.

We have just gotten started with the analysis, and we have already run through our vocab list:

• 1. Supervised Learning
• 2. Classification Task
• 3. Regression Task
• 4. Association Task
• 5. Prediction Task
• 6. Feature

These are key terms you will be hearing constantly as we move through the course. If you have any questions about them, please let me know!

Exploratory Data Analysis (EDA)

Once we have the data and know the goal of the analysis, the next step is to start to look at the data. We refer to the process of exploring the data as exploratory data analysis, or EDA. This means using graphs, charts, tables, and other such approaches to explore the data.

Let’s start by creating a summary of our response variable. In R, to tell the computer we wish to work with a single column in a data set (like body_mass_g), we use $. So, to tell the computer “Please go into the penguins data set and look at only the body mass column”, we use penguins$body_mass_g. This means that to get a summary of that single column, we use:

summary(penguins$body_mass_g)

We can also use the code below to obtain the same result.

summary(penguins[, "body_mass_g"])

This means that to select one column in R you have two choices:

• 1. data$nameOfColumn
• 2. data[ , "nameOfColumn"]

penguinsClean <- na.omit(penguins)

library(rlang)

suppressMessages(library(ggplot2))

ggplot(penguinsClean, aes(x =flipper_length_mm, y=body_mass_g)) +
  geom_point(col = 'blue')

ggplot(penguinsClean, aes(x =flipper_length_mm, y=body_mass_g)) +
  geom_point(col = 'blue') +
  labs(title="Figure 1:", x = "Flipper Length (in mm)",
  y = "Body Mass (in grams)", caption = "A scatter plot of 
  fliiper length versus body mass") 

# Install the packages
remotes::install_github("MatthewBJane/theme_park")
library(ThemePark)

# Make the scatter plot
ggplot(penguinsClean, aes(x=flipper_length_mm, y = body_mass_g)) + 
  geom_point(color = barbie_theme_colors["medium"]) +
  labs(title = 'Barbie Scatter Plot', x = "Flipper Length (mm)", y = "Body Mass (grams)") +
  theme_barbie()

head(themepark_themes)

Stacking Graphs

Client 1 now also informs us that when building the model to explore the relationship between flipper length and body mass, it is important to control for bill length, species, and sex. This means that, ideally, we’d like to make a plot to explore the relationship between each of these features and the response. That starts to take up a lot of space in a report. One nice way to present multiple graphs is to stack them.

Suppose I want to make a histogram of body mass. The code I need for that is:

ggplot(penguinsClean, aes(body_mass_g)) +
  geom_histogram(bins = 20, fill = "blue", col = "white")

If I put that in a chunk and press play, one histogram will appear on my screen. Let’s suppose I want to show a box plot along with this histogram. I can create both graphs and have them both print out separately in my knit document. However, I can also tell the computer to print more than one graph at once to save space. Try the following:

# First graph 
g1<- ggplot(penguinsClean, aes(body_mass_g)) +
  geom_histogram(bins = 20, fill = "blue", col = "white")+
    labs(title ="Figure 1") 

# Second graph 
g2 <- ggplot(penguinsClean, aes(body_mass_g)) +
  geom_boxplot(fill = "white", col = "blue") +
    labs(title ="Figure 2") 

# Stack the two graphs 
gridExtra::grid.arrange(g1,g2, ncol = 2)

If you get a warning message about not having gridExtra, this means you will need to install the package using the same steps we did above to install ggplot2. We have to install packages all the time with R, depending on the version of R you have and your computer system.

What you will notice is that we have stored each of the two graphs under a name. Our histogram is stored under g1 and our box plot is stored under g2. Then, we use a special code called gridExtra::grid.arrange to help us arrange the graphs in a grid. In our case, we have to graphs, and we want them side by side. This means we want the graphs in a 1 (row) by 2 (column) grid.

To create the 1 by 2 grid, we feed the computer our two graphs, and then tell it we want the figures in 2 columns (next to each other) by specifying ncol = 2. In other words, the number of columns we want is 2!

Making Tables

While we are thinking about professional formatting, let’s talk about tables. If I want to know about the species or islands in this data set, do we really want to see hundreds of rows of information on species or islands? Probably not. What we actually want to do is look at some sort of summary of the data. For categorical data like this, a table is most useful for this.

There are several ways to make tables in R, but we will discuss two. The first is very direct. We tell R we want to use the penguins data set and the variable species, by using the code penguinsClean$species (dataset$variable). Then, we use the table(whatWeWantToMakeATableWith) command to actually make the table.

table(penguinsClean$species)

However, this makes a table that is not particularly pretty or professional when you knit. A second option that does create professional tables is:

knitr::kable(table(penguinsClean$species), col.names=c("Species", "Count") )

The code is more complex, but the heart of it is the same table. This table will not look very pretty when you press play, but go ahead and knit. See how nicely the table gets formatted?

Okay, so now we can summarize the data by looking at the islands and the species. What if we want to look at them together? In other words, what if I want to know which species of penguins are on which islands? Can I do that?

knitr::kable(table(penguinsClean$species, penguinsClean$island)) 

Why would this be important? Well, when we are building models, we might need to know whether or not our groups were balanced before choosing a model. What if we had only male penguins from Dream Island, and then tried to fit a model looking at the relationship between penguin sex and beak length on this island. We couldn’t do it, because we only have information on male penguins. This is why taking the time to perform exploratory data analysis, and really dig into the data, is so important.

Combining Categorical and Numeric Variables

At this point in the lab, we have explored numeric and categorical variables separately. What if we want to make a plot that shows the relationship among flipper length, species, and body mass, all once? We could, perhaps, make a scatter plot, and then just use colors to separate out the different types of penguins. To do this, we include a color command in the specification of the axes.

ggplot(penguinsClean, aes(x=flipper_length_mm, y = body_mass_g, color = species)) + 
  geom_point() 

Here, the command color=species tells R that we want each dot to be colored in a way that corresponds to the species of the penguin. If we want to change the shape of the dots instead of the color, or addition to changing the color, we can use pch=species.

There is another option that allows us to compare the three variables. Instead of trying to create one plot, we can facet our plot. Faceted plots take a particular variable, such as the type of track condition, and create plots that are divided by that variable. To see an example, run the code below.

ggplot(penguinsClean, aes(x=flipper_length_mm, y = body_mass_g, color = species)) + 
  geom_point() + 
  facet_wrap( ~ species, ncol=3)

This is the same code we used above, with the addition of the line facet_wrap( ~ species, ncol=3). Let’s break this addition down. The command facet_wrap tells R that we are going to separate our graphs based on some categorical variable. The specific variable is then chosen with the code ~species. We are then able to specify how we want the graphs to be stacked. We want to allow 3 columns ( ncol=3).

Before you submit

One last step before we knit. Look at the very first chunk in your Markdown file. You should see something like knitr::opts_chunk$set(echo = TRUE). Change this to knitr::opts_chunk$set(echo = FALSE). What this will do is hide all the code you have created from your final document. All your plots will still show up, but your code will not.

Next Steps

For today, we started to explore this penguin data set, and some of what we can do in R. As we move through our semester, we will use the types of commands we learned today over and over. Let me know if you have any questions!

Turning in your assignment

When your Markdown document is complete, do a final knit and make sure everything compiles. You will then submit your document on Canvas. You must submit a PDF or html document to Canvas. No other formats will be accepted. Make sure you look through the final document to make sure everything has knit correctly.

References