- \n
- A Quick Review of Scatterplots<\/a><\/li>\n
- Syntax<\/a><\/li>\n
- Examples<\/a><\/li>\n<\/ul>\n
But it’s probably better if you read the whole tutorial. Everything will make more sense that way.<\/p>\n
<\/a><\/p>\n
A Quick Review of Scatterplots<\/h2>\n
Let’s quickly review what a scatterplot is.<\/p>\n
Scatterplots visualize numeric data. Specifically, a scatterplot show the relationship between two numeric variables, where the values of one variable are plotted on the x-axis and the values of the other variable are plotted on the y-axis.<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/05\/scatterplot-explanation.png\")
<\/p>\nScatterplots are extremely useful tools for showing the relationship between two numeric variables. For data visualization, reporting, and analytics, you’ll use them over and over.<\/p>\n
Scatter Plots in R<\/h3>\n
If you need to create a scatter plot in R, you have at least two major options, which I’ll discuss briefly.<\/p>\n
- \n
- base R<\/li>\n
- ggplot<\/li>\n<\/ul>\n
I strongly prefer the ggplot2 scatterplot, but let me quickly talk about both.<\/p>\n
base R scatterplots<\/h4>\n
You can create a scatterplot in R using the
plot()<\/code> function.<\/p>\nI’m going to be honest: I strongly dislike the base R scatterplot, and I strongly discourage you from using the
plot()<\/code> function. <\/p>\nLike many tools from base R, the
plot()<\/code> function is hard to use and hard to modify beyond making simple modifications. The syntax is clumsy, hard to remember, and often inflexible.<\/p>\nI haven’t used the
plot()<\/code> function to create a scatterplot in R in almost a decade. There’s a better way …<\/p>\nggplot2 scatterplots<\/h4>\n
If I need to make a scatter plot in R, I always use ggplot2. <\/p>\n
If you’re an R user, you’ve probably heard of ggplot2. The ggplot2 package is a toolkit for doing data visualization in R<\/a>, and it’s probably the best toolkit for making charts and graphs in R. In fact, once you know how to use it, ggplot2 is arguably one of the best data visualization toolkits on the market, for any programming language.<\/p>\n
ggplot2 is powerful, flexible, and the syntax is extremely intuitive, once you know how the system works.<\/p>\n
If you need to make a scatterplot in R, I strongly recommend that you use ggplot2<\/em>.<\/p>\n
Having said all of that, let’s take a look at the syntax for a ggplot scatterplot.<\/p>\n
<\/a><\/p>\n
The syntax for a ggplot scatterplot<\/h2>\n
The secret to using ggplot2 properly is understanding how the syntax works.<\/p>\n
If you’re not familiar with how the ggplot2 system works, you might want to read our introduction to ggplot2 tutorial<\/a>. That tutorial explains most of the basics of the ggplot system.<\/p>\n
At a high level, the syntax for a ggplot2 scatterplot looks something like this:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/05\/ggplot-scatterplot_simple-syntax-explanation.png\")
<\/p>\nThere are a few critical pieces to this syntax that you need to know:<\/p>\n
- \n
- The
ggplot()<\/code> function<\/li>\n- The
data =<\/code> parameter<\/li>\n- The
aes()<\/code> function<\/li>\n- Geometric objects (AKA, “geoms”)<\/li>\n<\/ul>\n
Let’s take a look at each of those separately.<\/p>\n
The ggplot function<\/h3>\n
The
ggplot()<\/code> function is simply the function that we use to initiate a ggplot2 plot.<\/p>\nYou’ll use this every time that you want to make any type of data visualization with ggplot2. However, the other parameters and functions you use along with it will dictate exactly what visualization gets created.<\/p>\n
The data parameter<\/h3>\n
The
data<\/code> parameter tells ggplot2 the name of the dataframe that you want to visualize. When you use ggplot2, you need to use variables that are contained within a dataframe. The data parameter tells ggplot where to find those variables.<\/p>\nSo for example, if your dataframe is named
my_dataframe<\/code>, you will setdata = my_dataframe<\/code>. <\/p>\nRemember: ggplot2 operates on dataframes.<\/p>\n
The aes function<\/h3>\n
The
aes()<\/code> function tellsggplot()<\/code> the “variable mappings.” This might sound complex, but it’s really straightforward once you understand.<\/p>\nWhen we visualize data, we are essentially connecting variables in a dataframe to parts of the plot. For example, when we make a scatter plot, we “map” one numeric variable to the x axis, and another numeric variable to the y axis. We map these variables to different axes within the visualization.<\/p>\n
The
aes()<\/code> function allows us to specify those mappings; it enables us to specify which variables in a dataframe should connect to which parts of the visualization. If this doesn’t make sense, just sit tight. I’ll show you an example in a minute.<\/p>\n(For more detailed explanation of the
aes()<\/code> function, read the section about theaes()<\/code> function<\/a> in our ggplot2 tutorial.)<\/p>\nThe point “geom”<\/h3>\n
Finally, a geometric object is the thing that we draw. <\/p>\n
When you create a bar chart, you draw “bar geoms.” When you create a line chart, you draw “line geoms.” And when you create a scatter plot, you are draw “point geoms.” <\/p>\n
The geom is the thing that you draw.<\/p>\n
In ggplot2, we need to explicitly state the type of geometric object that we want to draw (i.e., bars, lines, points, etc). <\/p>\n
When create a scatter plot, we draw point geoms (i.e., points). To specify that we want to draw points, we call
geom_point()<\/code>.<\/p>\nAdditional parameters<\/h3>\n
There are also a few additional parameters that you can use to control the appearance of the points in your scatterplot.<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/05\/ggplot_syntax_additional-parameters.png\")
<\/p>\nSpecifically, the most important parameters you should know are:<\/p>\n
- \n
- color<\/li>\n
- size<\/li>\n
- alpha<\/li>\n<\/ul>\n
Let me quickly discuss each of these.<\/p>\n
Color<\/h4>\n
The
color<\/code> parameter controls the color of the points.<\/p>\nWhen you provide an argument to this parameter, you can provide a “named” color like
red<\/code>,green<\/code>,blue<\/code>, etc. R has a variety of named colors<\/a>, so explore them and find some you like.<\/p>\nKeep in mind, that when you provide the color name, it needs to be enclosed inside of quotation marks. So for example, you’ll set
color = 'red'<\/code>.<\/p>\nSize<\/h4>\n
The size parameter enables you to specify the size of the points.<\/p>\n
If you want to play with this parameter, there’s not a perfect way to choose a good size, so I recommend that you use some trial and error to find one that works. <\/p>\n
You can also use this parameter to create a bubble chart, but that’s slightly more complicated, so we won’t cover it here.<\/p>\n
Alpha<\/h4>\n
The
alpha<\/code> parameter enables you to modify the opacity of the points (i.e., how transparent the points are). <\/p>\nThis value needs to be between 0 and 1, where: <\/p>\n
- \n
- 1 is fully opaque<\/li>\n
- 0 is fully transparent<\/li>\n<\/ul>\n
By default, this parameter is set to
alpha = 1<\/code>.<\/p>\nThis parameter is very useful when you have a large number of points, and your scatterplot has an issue with overplotting. Dealing with overplotting is somewhat of a nuanced issue, but one way to handle it is by decreasing the
alpha<\/code> value. <\/p>\nI’ll show you an example of this in the examples.<\/p>\n
<\/a><\/p>\n
Examples: How to make scatterplots with ggplot2<\/h2>\n
Ok. Now that I’ve quickly reviewed how the syntax works for a ggplot2 scatterplot, let’s take a look at some examples of how to create a scatter plots in R with ggplot.<\/p>\n
Examples:<\/strong><\/p>\n
- \n
- Create a simple scatterplot with ggplot2<\/a><\/li>\n
- Change the Color of the Points<\/a><\/li>\n
- Change the Size of the Points<\/a><\/li>\n
- Add a LOESS Smooth Line<\/a><\/li>\n
- Add a Linear Regression Line<\/a><\/li>\n<\/ul>\n
Run this code first!<\/h3>\n
A few quick things before you run the examples.<\/p>\n
You’ll need to run some code to load
ggplot2<\/code> and also to create the dataset that we’ll be working with.<\/p>\nLoad the tidyverse package<\/h4>\n
First, you need to make sure that you’ve loaded the ggplot2 package. <\/p>\n
Actually, I recommend that you load the
tidyverse<\/code> package. Remember that thetidyverse<\/code> package includesggplot2<\/code>.<\/p>\nKeep in mind that this also assumes that you’ve installed<\/em> the
tidyverse<\/code> package on in RStudio.<\/p>\n\r\nlibrary(tidyverse)\r\n<\/pre>\n
Create a sample dataset<\/h4>\n
Next, we’ll need to create a dataset to plot.<\/p>\n
Here, we’re going to create a new dataframe called,
scatter_data<\/code>.<\/p>\n\r\nset.seed(55)\r\nscatter_data <- tibble(x_var = runif(100, min = 0, max = 25)\r\n ,y_var = log2(x_var) + rnorm(100)\r\n )\r\n<\/pre>\n
We can take a look at this dataframe with the following code:<\/p>\n
\r\nscatter_data %>% glimpse()\r\n<\/pre>\n
OUT:<\/p>\n
\r\nRows: 100\r\nColumns: 2\r\n$ x_var
13.6953379, 5.4539920, 0.8740999, 19.7887324, 14.0060519, 1.8556294, 3.2\u2026\r\n$ y_var 2.6122496, 2.7738665, -1.2230670, 3.6239948, 3.6479324, 1.1145059, 2.244\u2026\r\n<\/pre>\n As you can see, this dataframe has two variables,
x_var<\/code> andy_var<\/code>. We'll be able to plot these variables as a scatterplot.<\/p>\n<\/a><\/p>\n
EXAMPLE 1: Create a simple scatterplot with ggplot2<\/h3>\n
Now that we have our dataframe,
scatter_data<\/code>, we'll plot it with ggplot2.<\/p>\nLet's run the code first, and then I'll explain.<\/p>\n
\r\nggplot(data = scatter_data, aes(x = x_var, y = y_var)) +\r\n geom_point()\r\n<\/pre>\n
OUT:<\/p>\n
![\"Scatter](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/08\/scatter-plot-in-r-made-with-ggplot2.png\")
<\/p>\nExplanation<\/h5>\n
As you can see, this code has created a simple scatter plot. It's pretty straightforward, but let me explain it.<\/p>\n
We're initiating the ggplot2 plotting system by calling the
ggplot()<\/code> function.<\/p>\nInside of the
ggplot2()<\/code> function, we're telling ggplot that we'll be plotting data in thescatter_data <\/code> dataframe. We do this with the syntaxdata = scatter_data<\/code>.<\/p>\nNext, inside the
ggplot2()<\/code> function, we're calling theaes()<\/code> function. Remember, theaes()<\/code> function enables us to specify the \"variable mappings.\" Here, we're telling ggplot2 to put our variablex_var<\/code> on the x-axis, and puty_var<\/code> on the y-axis. Syntactically, we're doing that with the codex = x_var<\/code>, which mapsx_var<\/code> to the x-axis, andy = y_var<\/code>, which mapsy_var<\/code> to the y-axis.<\/p>\nFinally, on the second line, we're using
geom_point()<\/code> to tell ggplot that we want to draw point geoms (i.e., points). <\/p>\nThat's it. That's all there is to it. The syntax might look a little arcane to beginners, but once you understand how it works, it's pretty easy.<\/p>\n
Having said that, there are still a few enhancements we could make to improve the chart. Let's talk about a few of those.<\/p>\n
<\/a><\/p>\n
EXAMPLE 2: Change the Color of the Points<\/h3>\n
Now, we'll make a simple modification by changing the color of the scatterplot points.<\/p>\n
To change the color of the points to a solid color, we need to use the
color<\/code> parameter.<\/p>\n\r\nggplot(data = scatter_data, aes(x = x_var, y = y_var)) +\r\n geom_point(color = 'red')\r\n<\/pre>\n
OUT:<\/p>\n
![\"Scatterplot](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/05\/ggplot2-scatterplot_red-points.png\")
<\/p>\nExplanation<\/h5>\n
Again, this is very straightforward.<\/p>\n
To create this, we just set
color = 'red'<\/code> inside ofgeom_point()<\/code>. We do this inside ofgeom_point()<\/code> because we're changing the color of the points. (There are more complex examples were we have multiple geoms, and we need to be able to specify how to modify one geom layer at a time.)<\/p>\n<\/a><\/p>\n
EXAMPLE 3: Change the Size of the Points<\/h3>\n
In this example, we'll change the size of the points.<\/p>\n
We can do that with the
size<\/code> parameter.<\/p>\n\r\nggplot(data = scatter_data, aes(x = x_var, y = y_var)) +\r\n geom_point(color = 'red', size = 4)\r\n<\/pre>\n
OUT:<\/p>\n
![\"An](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2021\/05\/ggplot2-scatterplot_large-points-size-4.png\")
<\/p>\nExplanation<\/h5>\n
Here, we've increased the size of the points by setting
size = 4<\/code> inside ofgeom_point()<\/code>.<\/p>\nNow, to be clear: I'm not sure that I like this scatterplot with larger points. I actually think that the defaults were just fine.<\/p>\n
Having said that, sometimes, you need to increase or decrease the size of your scatterplot points, so I wanted to show you how it's done.<\/p>\n
As a side note, decreasing<\/em> the size of your points can be a great way to deal with overplotting. Try it with the
diamonds<\/code> dataframe fromggplot2<\/code>.<\/p>\n<\/a><\/p>\n
EXAMPLE 4: Add a Smooth Trend Line<\/h3>\n
Now, we'll add a smooth trend line.<\/p>\n
To add a smooth line, we can use the statistical operation
stat_smooth()<\/code>.<\/p>\n\r\nggplot(data = scatter_data, aes(x = x_var, y = y_var)) +\r\n geom_point(color = 'red') +\r\n stat_smooth()\r\n<\/pre>\n
OUT:<\/p>\n
![\"A](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/08\/ggplot-scatter-plot-in-r-with-smooth-line.png\")
<\/p>\nExplanation<\/h5>\n
Here, we added a smooth line by adding the code
stat_smooth()<\/code> after the scatterplot code.<\/p>\nNotice that the first two lines are exactly the same as the code for our simple scatterplot (with red points). <\/p>\n
So to add the smooth line, we simply use the '
+<\/code>' and thenstat_smooth()<\/code>.<\/p>\nThis is one of the reasons that ggplot2 is so great. Frequently, modifications to a simple plot only require you to tack on a call to an additional function. So you can build the base version of a plot, and then enhance it by adding new lines of code.<\/p>\n
Keep in mind that the default trend line is a LOESS smooth line, which means that it will capture non-linear relationships.<\/p>\n
But, you can also add a linear trend line. Let's do that next.<\/p>\n
- Change the Color of the Points<\/a><\/li>\n
- Create a simple scatterplot with ggplot2<\/a><\/li>\n
- The
- The
- Syntax<\/a><\/li>\n
![\"ggplot](\"https:\/\/www.sharpsightlabs.com\/wp-content\/uploads\/2018\/08\/ggplot-scatter-plot-in-r-with-straight-line.png\")
<\/p>\n