This lesson covers intermediate data visualization concepts in R using the ggplot2 package.

Intermediate Data Visualization in R

Similarly to discrete variables, we can add a `scale_x_continuous()` layer to customize continuous variables on our `x` axis, or a `scale_y_continuous()` layer to customize continuous variables on our `y` axis. We can also add a `coord_cartesian` layer to specify the range of values shown on a given axis, allowing us to zoom in and out of the plot region. 

Continuing with our plot of sleep hours by diet, let’s set the `y` axis to be between `8` and `12`. Most animals sleep at least few hours a day, so we don't need our `y` axis to start exactly at `0`. We can adjust our `y` axis ranges by adding a `coord_cartesian()` layer and passing a vector `c(8, 12)` to its `ylim` argument, specifying the min and max values of the `y` axis.

```r
msleep_start <- 
  ggplot(msleep_error_df, 
         aes(x = diet, 
             y = mean.hours)) + 
  geom_bar(stat = "identity") + 
  geom_errorbar(aes(ymin = se.min, 
                    ymax = se.max), 
                width = 0.2) + 
  scale_x_discrete(
    limits = c("omni", "carni", "herbi"), 
    labels = c("carni" = "Carnivore", 
               "herbi" = "Herbivore", 
               "omni" = "Omnivore")) +
  labs(title = "Mean Hours Asleep by Diet")

msleep_continuous <- 
  msleep_start + 
  coord_cartesian(ylim = c(8, 12))
```

Now our plot looks like this. Our `y` axis begins at `8` and ends at `12` as we specified. The differences between each bar’s height are much more obvious -- omnivores sleep the most on average, while herbivores sleep the least!

![Axes Ranges: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/continuous_example-1.png)

We can also customize the labels shown for the `y` axis tick marks using the `breaks` argument of the `scale_y_continuous()` layer. In the code below, we pass a vector `c(8, 10, 12)` to specify that we only want tick marks on the `y` axis to appear at `8`, `10`, and `12`. 

```r
msleep_continuous <- 
  msleep_start + 
  coord_cartesian(ylim = c(8, 12)) +
  scale_y_continuous(breaks = c(8, 10, 12))
```

Here is our new plot: 

![Axes Ranges: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/continuous_example-2.png)

Finally, we can apply custom transformations to our tick mark labels. Let’s say we want to add a unit of measurement "hrs" to each number on the `y` axis. We can pass a custom function to the `labels` argument of `scale_y_continuous()`. Here, we are telling `ggplot2` to take the automatic labels and add the characters `" hrs"` after each label. 
```r
show_as_hours <- function(x) {
  output <- paste0(x, " hrs")
  return(output)
}

msleep_continuous <- 
  msleep_start + 
  coord_cartesian(ylim = c(8, 12)) +
  scale_y_continuous(labels = show_as_hours, 
                     breaks = c(8, 10, 12))
```
Here’s what our plot with its newly labeled `y` axis looks like: 

![Axes Ranges: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/continuous_example-3.png)

Customizing Continuous Axes

Facets allow us to visualize multiple discrete variables in one plot, showing each value of the facet variable in a different section.  

The plot below shows our familiar hours slept by diet plot, this time with the addition of a third variable describing the taxonomic order of animals in our data. We see that rodents of all three diet types sleep much more than primates! 

![Facets: Mean Hours Asleep by Diet and Order](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/facet_example-1.png)

We can add facets to our plot by adding a `facet_grid()` layer and specifying the variables it maps to. To show values of a facet variable as rows, we specify `facet_grid(rows = vars(row.var))`. To show values of a facet variable as columns, we specify `facet_grid(columns = vars(col.var))`. We can also show two facet variables in a grid, e.g. `facet_grid(rows = vars(row.var), columns = vars(col.var))`. 

The code below produces the plot shown at the beginning of this exercise. First, we process our data frame to include the records we want and calculate mean hours asleep. Next, we create our sleep by diet plot, this time mapping the `order` variable to a `facet_grid()` layer split into columns. 
```r
msleep_facets_df <- msleep %>%
  filter(status == "asleep") %>%
  na.omit() %>%
  group_by(diet, order) %>%
  summarize(mean.hours = mean(hours)) %>%
  filter(order %in% c("Primates", "Rodentia"))

msleep_facet <- 
  ggplot(msleep_facets_df, 
         aes(x = diet, y = mean.hours)) + 
  geom_bar(stat = "identity") + 
  labs(title = "Mean Hours Asleep by Diet") +
  scale_x_discrete(
    limits = c("omni", "carni", "herbi"),
    labels = c("carni" = "Carnivore",
               "herbi" = "Herbivore", 
               "omni" = "Omnivore")) +
  facet_grid(cols = vars(order))
```

Facets

In this lesson, we’ll explore a variety of different visualizations in R’s [ggplot2](https://ggplot2.tidyverse.org/) package. We’ll also go over different ways we can customize our plots to better communicate data insights. 

Let’s start with a familiar visualization: the scatter plot, which we can create using a `geom_point()` layer in `ggplot2`. Scatter plots are useful for visualizing the relationship between two variables. The scatter plot below shows the correlation between a movie’s IMDB rating and the number of awards it has won. Unsurprisingly, movies with higher ratings tend to win more awards! 

![Scatter Plot](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/intro-scatterplot.png)

Another common plot is the bar plot. Bar plots are useful for visualizing values for variables that can be counted, such as discrete variables (e.g. integers `1, 2, 3`) or categorical variables (e.g. `"cat", "dog", "mouse"`). We can create bar plots using a `geom_bar()` layer in `ggplot2`. The bar plot below shows how many car models of each class are present in the `mpg` dataset. In this lesson, we'll look at statistical transformations that allow us to display summary values in a bar plot, such as means, and different ways of positioning bars within our bar plots. 

![Bar Plot](https://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/intro-barplot.png)

While each geom can visualize many kinds of data, some geoms communicate certain insights more clearly than others. For example, if we wanted to see the distribution of height among the U.S. population, a bar plot wouldn’t be the best choice because height is a continuous variable with many possible values.

Sometimes we might also need to visualize data across more than two variables. In this lesson, we’ll cover the concept of “facets” which let us show additional discrete variables (in addition to `x` and `y` axes) by dividing a plot into different sections. 

Lastly, we’ll often want to adjust the axes of our plots, add error bars to show variance, and more. By the end of this lesson, you'll know how to create and customize many kinds of data visualizations using `ggplot2`. Let's get started!


Hours of Day by Sleep State, Diet, and Order

Introduction

Frequently, we’ll want to customize our axes to represent our data more clearly. For discrete variables, such as categories on the `x` axis of a bar plot, we may want to specify a particular order these values appear in. Or, we might want to rename the axes labels so they better describe each value.

We can customize discrete variables on the `x` axis with the `scale_x_discrete()` layer. There is also a `scale_y_discrete()` layer that works the same way for variables on the `y` axis. 

Let’s take a look at the hours of sleep by diet plot we created in the last exercise. We can pass a vector to the `limits` argument in `scale_x_discrete()` to specify that we only want to show bars for `c("omni", "carni", "herbi")`, in that order rather than the default alphabetical ordering. 
```r
msleep_start <- 
  ggplot(msleep_error_df, 
         aes(x = diet, 
             y = mean.hours)) + 
  geom_bar(stat = "identity") + 
  geom_errorbar(aes(ymin = se.min, 
                    ymax = se.max), 
                width = 0.2) + 
  labs(title = "Mean Hours Asleep by Diet")

msleep_discrete <- 
  msleep_start +
  scale_x_discrete(
    limits = c("omni", "carni", "herbi"))
```
This produces the following plot. `"insecti"` is now omitted on the `x` axis. `"omni"` appears on the left, whereas it would appear on the right in the default alphabetical ordering.

![Discrete Axes Limits: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/discrete_example-1.png)

We might also want the labels to be more descriptive -- for example, `"carnivore"` is a more familiar word compared to `"carni"`. We can pass a vector of value-to-label mappings to the `labels` argument in `scale_x_discrete()` to specify what we want to show for each existing value. 
```r
msleep_discrete <- 
  msleep_start + 
  scale_x_discrete(
    limits = c("omni", "carni", "herbi"), 
    labels = c("carni" = "Carnivore", 
               "herbi" = "Herbivore", 
               "omni" = "Omnivore"))
```
This produces the following plot. Now the labels are much more clear! The ordering we specify in `limits` is still preserved. 

![Discrete Axes Labels: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/discrete_example-2.png)

Customizing Discrete Axes

By default, bar plots using `geom_bar()` show the count of observations for each value. We can also show other types of data, such as calculating and showing the mean instead.

Let’s say we want to see how much an animal sleeps on average by the kind of food it eats, based on the `msleep` dataset. The code below does just that! Recall that passing `stat = "identity"` to a `geom_bar()` layer tells `ggplot2` to display values as is, rather than count the number of occurrences. We can similarly use `stat = "summary"`, which tells `ggplot2` to summarize values according to a provided function. We can specify `fun = "mean"` to summarize our `y` axis variable by calculating mean values for each value in our `x` axis variable. 

```r
# Filter our data to include only hours spent asleep, omitting NA values
msleep_means_df <- msleep %>%
  filter(status == "asleep") %>%
  na.omit()

# Construct a bar plot calculating and displaying means
msleep_meanbar <- 
  ggplot(msleep_means_df, 
         aes(x = diet, 
             y = hours)) + 
  labs(title="Mean Hours Asleep by Diet") +
  geom_bar(stat = "summary", 
           fun = "mean")
```
Here's how this plot looks. In the `msleep` dataset, insectivores (animals that eat insects) sleep for fifteen hours a day on average, which is far more than animals with other diets!

![Bar Plot: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/meanbar_example-1.png)

Statistical Summaries

Instead of stacking our `fill` variable in our bar graphs, we can also represent values of the variable side by side. This is known as a clustered bar plot. 

The plot below visualizes our `msleep` data for elephants as a clustered bar plot instead of a stacked bar plot. Notice how the values shown are the same as in our stacked bar plot, but the positioning is now different. 

![Clustered Bar Plot: Hours of Day by Sleep State](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/clusteredbar_example-1.png)

We can easily create a clustered bar plot by setting `position = "dodge"` instead of `position = "stack"` in our geom. The `dodge` positioning tells `ggplot2` to display each value of the `fill` variable next to each other (as opposed to on top of each other in `"stack"`). Once again, we can either use `geom_bar(stat = "identity")` or `geom_col()`.

```r
# Filter our data to include only elephants
msleep_clustered_df <- msleep %>%
  filter(order == "Proboscidea")

# Construct a clustered bar plot
msleep_stackedbar <- 
  ggplot(msleep_clustered_df, 
         aes(x = name, 
             y = hours, 
             fill = status)) + 
  labs(title = "Hours of Day by Sleep State") +
  geom_bar(position = "dodge", 
           stat = "identity")

# This creates the same plot!
msleep_stackedbar <- 
  ggplot(msleep_clustered_df, 
         aes(x = name, 
             y = hours, 
             fill = status)) + 
  labs(title = "Hours of Day by Sleep State") +
  geom_col(position = "dodge")
```

Clustered Bar Plots

Box plots, also known as box-and-whisker plots, show the distribution of data by quartiles. Box plots are useful in showing how much a variable varies across values of another variable -- are most cases similar in value, or is there a wide range between the highest and lowest values? 

In the box plot below, we see the distribution of temperatures for different months within a subset of the `airquality` dataset. As we would expect for New York City, the summer months have the highest temperatures. The center of the box represents the median temperature. The upper and lower bounds of the box show the 75th and 25th percentiles respectively. The whiskers extend up to 1.5 times the distance between the 75th and 25th percentiles. Beyond the whiskers, outliers are shown as points. 

![Box Plot: Temperature by Month](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/anotated_box_plot.svg)

We can create a box plot using the `geom_boxplot()` layer. The code below creates the box plot shown above, visualizing temperature by month in the `airquality` data.
```r
airquality_boxplot <- 
  ggplot(airquality, 
         aes(x = Month, y = Temp)) + 
  labs(title = "Air Quality: Temperature by Month") +
  geom_boxplot()
```
Note that box plots show medians, not means. We'll cover how to display mean values using bar plots later in this lesson.

Box Plots

Histograms let us visualize the distribution of a continuous variable, in contrast to bar plots which show counts and other values for discrete and categorical variables. Histograms divide values of a variable into bins, which are ranges of values that get counted together. For example, if a variable had values `1` through `100` and we specify that we want 5 bins, each bin would have a range of `100 / 5 = 20`. The first bin would count the frequency of values `1` to `20`, the second bin would count the frequency of values `21` to `40`, and so on. 

We can construct a histogram using `geom_histogram()`. The code below creates a histogram using R's built-in `airquality` dataset containing atmospheric measurements from New York City. This histogram shows frequencies of `Ozone` values, measuring the amount of air pollution recorded within a given time period.  

```r
airquality_histogram <- 
  ggplot(airquality, aes(x = Ozone)) +
  labs(title = "Air Quality: Ozone Distribution") +
  geom_histogram()
```
This produces the following plot. We see that ozone levels are clustered towards the lower end of the range (a good thing!), though there were days with much higher ozone levels as well.

![Histogram](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/hist_example-1.png)

By default, `ggplot2` automatically calculates 30 equally sized bins. Frequently we’ll want to specify a range per bin that better fits our data; for example, if we wanted to examine the distribution of weight in pounds for a population of house cats, it would make sense for each bin to represent one pound rather than some arbitrary decimal amount. We can set the width of bins using the `binwidth` argument. The code below creates the same plot as before, now with a `binwidth` of `10`.  

```r
airquality_histogram_binwidth <- 
  ggplot(airquality, aes(x = Ozone)) + 
  labs(title = "Air Quality: Ozone Distribution") +
  geom_histogram(binwidth = 10)
```
Take a look at our new plot with `binwidth` set to `10`. Notice how the shape of the histogram is now more smooth with fewer local peaks. 

![Histogram](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/hist_example-2.png)

Histograms

Many times we are interested in seeing percentages within our data or how different values add up. We can do this using a stacked bar plot. 

Let’s turn to the `msleep` dataset included in `ggplot2` describing the number of hours spent asleep vs awake for various animals. We have pre-processed this data to include just the variables we care about. Take a look at the output panel to see how this dataset looks. 

Now, suppose we want to show the number of hours spent awake versus asleep each day for members of the order Proboscidea, i.e. elephants. We want to show this in a stacked bar plot because the hours awake versus asleep always add up to 24, and we are interested in depicting the proportion of each day spent in each state. The plot below tells us that for both African and Asian elephants, the vast majority of their day is spent awake.

![Stacked Bar Plot: Hours of Day by Sleep State](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/stackedbar_example-1.png)

The code below creates the plot we just saw. We specify a `fill` variable in our `aes()` mapping to tell `ggplot2` which variable should be depicted as color-coded segments within our stacked bars. Adding `stat = "identity"` to `geom_bar()` displays the values in our data frame as is, rather than displaying counts. 

```r
# Filter our data to include only elephants
msleep_filtered <- msleep %>%
  filter(order == 'Proboscidea')

# Construct a stacked bar plot
msleep_stackedbar <- 
  ggplot(msleep_stacked_df, 
         aes(x = name, 
             y = hours, 
             fill = status)) + 
  geom_bar(stat = "identity") +
  labs(title = "Hours of Day by Sleep State")
```
We can explicitly add `position = "stack"` in our geom telling it to stack different values of the `fill` variable on top of each other; this is also assumed by default if we don’t specify any positioning. 
```r
# This creates the same plot!
msleep_stackedbar <- 
  ggplot(msleep_stacked_df, 
         aes(x = name, 
             y = hours, 
             fill = status)) + 
  geom_bar(position = "stack", 
           stat = "identity") +
  labs(title = "Hours of Day by Sleep State")
```
We can also create this same plot using the `geom_col()` geom, which works just like `geom_bar()` except it assumes `stat = "identity"` by default.
```r
# This also creates the same plot!
msleep_stackedbar <- 
  ggplot(msleep_stacked_df, 
         aes(x = name, 
             y = hours, 
             fill = status)) + 
  geom_col() +
  labs(title = "Hours of Day by Sleep State")
```

Stacked Bar Plots

You've completed the Data Visualization in R lesson! You now know how to choose and implement different kinds of geoms in `ggplot2`, how to customize your plot axes, and how to visualize additional variables through facets. 

Below is a summary of the key concepts you learned -- great job!

**How to create different geoms and when to use which type:**
  * Histograms can be created using `geom_histogram()` to show the distribution of a continuous variable.
  * Heatmaps can be created using `geom_bin2d()` to show the distribution of the intersections of two continuous variables.
  * Box-and-whisker plots can be created using `geom_boxplot()` to show the distribution of a continuous variable by quantiles, e.g. 25th, 50th, and 75th percentiles.
  * Bar plots can be created using `geom_bar()`, which shows the count of observations for different values of a discrete variable by default. `geom_col()` will create bar plots showing the value of the variable on the `y` axis rather than counts.
  * Using the `position` argument and a `fill` aesthetic mapping, we can create stacked bar plots (`position = "stack"`), stacked bar plots showing ratios (`position = "fill"`), and clustered bar plots (`position = "dodge"`).

**How to show different statistics in our data:**
  * The `stat` argument allows us to display different kinds of values.
  * `stat = "identity"` will show the `y` axis variable values on a bar plot as is, rather than displaying the `x` axis value counts.
  * `stat = "summary"` combined with a function supplied in `fun` will display bar heights based on the summary function. For example, `stat = "summary", fun = "mean"` will calculate and display means.

**How to add error bars to bar plots to show variance around a mean:**
  * `geom_error()` creates error bars on bar plots when provided `ymin` and `ymax` variables representing the upper and lower bounds of error ranges.

**How to customize discrete and continuous axes:**
  * We can customize discrete axes using `scale_x_discrete()` and `scale_y_discrete()`. 
  * We can customize continuous axes using `scale_x_continuous()` and scale_y_continuous()`. 
  * We can zoom in on a region of our data using `coord_cartesian()`.

**How to show additional variables in panels of a grid using facets:**
  * By adding `facet_grid()`, we can map up to two additional variables along facet columns and rows.

Review

Often, we’ll want to show not only the mean of a value but also its standard error. This tells us how much variation there is around the mean -- are most values close to the averages shown, or is there a wide range of values above and below the average? 

To add error bars, we need to first calculate our standard errors. Continuing with our `msleep` dataset, the code below calculates means and standard errors for hours asleep by diet. We compute new variables `mean.hours` representing the mean of `hours`, `mean.se` representing the standard error of our means, and `se.min` and `se.max` representing the lower and upper bounds of our error range. 

```r
msleep_error_df <- msleep %>%
  subset(status = "asleep") %>%
  na.omit() %>%
  group_by(diet) %>%
  summarize(mean.hours = mean(hours), 
            mean.se = std.error(hours)) %>%
  mutate(se.min = mean.hours - mean.se, 
         se.max = mean.hours + mean.se)
```
We can then create our bar plot showing means and standard errors as follows. We add a `geom_errorbar()` layer specifying `ymin` and `ymax` variables for our error bar and set its width to `0.2` of the bar’s width. Because we’ve already calculated mean values in our summary data frame, we specify `stat = "identity"` to display the `mean.hours` values as is. 
```r
msleep_sebar <- 
  ggplot(msleep_error_df, 
         aes(x = diet, 
             y = mean.hours)) + 
  geom_bar(stat = "identity") + 
  geom_errorbar(aes(ymin = se.min, 
                    ymax = se.max), 
                width = 0.2) + 
  labs(title = "Mean Hours Asleep by Diet")
```
This produces the following plot, which should look familiar from the last exercise! Now that we have error bars, we can see how much variation there is around the mean hours asleep for each diet group.

![Error Bars: Mean Hours Asleep by Diet](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/errorbar_example-1.png)

Error Bars

Heatmaps let us visualize frequencies along two variables. A heatmap looks like a scatterplot, but uses color-coded squares rather than individual points to indicate how many cases occurred at the intersection of `x` and `y` value ranges. Like histograms, we can specify bin widths to control which ranges of values get counted together. 

Here’s an example heatmap using our `airquality` dataset, mapping `Ozone` values (ozone pollution) on the `x` axis and `Solar.R` values (solar radiation) on the `y` axis. Notice how each region in the heatmap is color-coded to the number of cases with values in the relevant bin ranges. In this dataset, there are many occurrences where both solar radiation levels and ozone levels are low. 

![Air Quality: Ozone and Solar Radiation](http://content.codecademy.com/programs/analyze-data-with-r/data-visualization-in-r/heatmap_example-1.png)

We can create heatmaps using the `geom_bin2d()` layer. This geom takes many of the same arguments as `geom_histogram()`, with slight differences given that a heatmap represents two variables. Like histograms, heatmaps automatically calculate 30 equally sized bins, which may not make sense for many datasets. To specify bin widths for each variable, we can pass a vector of widths instead of a single value, e.g. `geom_bin2d(binwidth = c(1, 5))` to set `x` axis bin widths to `1` and `y` axis bin widths to `5`.

The code below constructs the heatmap shown at the start of this exercise. We set the `binwidth` of both axes using a vector, specifying that each axis should use bins of width `25`. 

```r
airquality_heatmap <- 
  ggplot(airquality, 
         aes(x = Ozone, y = Solar.R)) + 
  labs(title = "Air Quality: Ozone and Solar Radiation") +
  geom_bin2d(binwidth = c(25, 25))
```