Eric Campbell 5 min read Data Science

How to Create a Pair Plot in ggplot2

Pair plots display pairwise relationships between multiple variables in a single visualization. Each variable in your dataset gets plotted against every other variable, creating a matrix of plots...

Key Insights

  • The GGally package provides ggpairs() as the most powerful way to create pair plots in the ggplot2 ecosystem, offering extensive customization options that base R’s pairs() function lacks
  • Pair plots become exponentially more complex with additional variables—for datasets with more than 8-10 variables, select specific columns or use dimensionality reduction first
  • Custom panel functions let you add statistical annotations like correlation coefficients or regression lines, transforming pair plots from simple visualizations into comprehensive exploratory analysis tools

Introduction to Pair Plots

Pair plots display pairwise relationships between multiple variables in a single visualization. Each variable in your dataset gets plotted against every other variable, creating a matrix of plots that reveals correlations, distributions, and patterns at a glance.

This visualization technique is invaluable during exploratory data analysis. Instead of creating dozens of individual scatter plots, you get a comprehensive view of how your variables interact. Pair plots help you identify correlated features, spot outliers, understand distributions, and make informed decisions about feature engineering and model selection.

While base R provides the pairs() function, the ggplot2 ecosystem offers more powerful alternatives through the GGally package. This approach gives you the aesthetic flexibility of ggplot2 with specialized functionality for multivariate visualization.

Basic Pair Plot with GGally::ggpairs()

The ggpairs() function from the GGally package is your primary tool for creating pair plots. Install it if you haven’t already with install.packages("GGally").

Here’s the simplest possible pair plot using the iris dataset:

library(ggplot2)
library(GGally)

# Basic pair plot with numeric variables
ggpairs(iris, columns = 1:4)

This creates a matrix of plots where:

  • The diagonal shows density plots for each variable
  • The lower triangle displays scatter plots
  • The upper triangle shows correlation coefficients

The default output is immediately useful. You can see that petal length and petal width are highly correlated (0.963), while sepal width has weak correlations with other variables. The diagonal density plots reveal that some variables have bimodal distributions, hinting at underlying groups in the data.

Let’s include the species information to make this more informative:

ggpairs(iris, columns = 1:4, aes(color = Species, alpha = 0.6))

Now the plots are color-coded by species, and you can see that the bimodal distributions correspond to different iris species. The transparency (alpha) prevents overplotting in dense regions.

Customizing Plot Types by Panel

The real power of ggpairs() emerges when you customize what appears in each panel type. The matrix has three distinct regions: upper triangle, lower triangle, and diagonal. You can specify different visualization types for each.

ggpairs(iris, 
        columns = 1:4,
        aes(color = Species, alpha = 0.6),
        upper = list(continuous = "cor", combo = "box_no_facet"),
        lower = list(continuous = "smooth", combo = "facetdensity"),
        diag = list(continuous = "densityDiag"))

Let’s break down these options:

  • upper = list(continuous = "cor"): Shows correlation coefficients in the upper triangle for continuous variable pairs
  • lower = list(continuous = "smooth"): Displays scatter plots with smoothed trend lines in the lower triangle
  • diag = list(continuous = "densityDiag"): Uses density plots on the diagonal

The combo parameter handles mixed variable types (continuous vs. categorical). Options include "box", "box_no_facet", "dot", "facethist", and "facetdensity".

For a more minimal approach focused on correlations:

ggpairs(iris,
        columns = 1:4,
        upper = list(continuous = "cor"),
        lower = list(continuous = "points"),
        diag = list(continuous = "barDiag"))

This configuration prioritizes the correlation coefficients while keeping the lower triangle as simple scatter plots and using bar plots on the diagonal.

Styling and Aesthetics

Since ggpairs() builds on ggplot2, you can apply themes and styling just like any ggplot object. However, some aesthetic mappings need to be specified within the ggpairs() call itself.

ggpairs(iris,
        columns = 1:4,
        mapping = aes(color = Species, alpha = 0.5),
        upper = list(continuous = wrap("cor", size = 5)),
        lower = list(continuous = wrap("points", size = 0.8)),
        diag = list(continuous = wrap("densityDiag", alpha = 0.5))) +
  theme_minimal() +
  theme(strip.text = element_text(size = 10, face = "bold"),
        axis.text = element_text(size = 8)) +
  labs(title = "Iris Dataset Pair Plot Analysis")

The wrap() function allows you to pass additional parameters to the plotting functions. Here we’re adjusting text size for correlations, point size for scatter plots, and transparency for density plots.

You can also create custom color palettes:

ggpairs(iris,
        columns = 1:4,
        mapping = aes(color = Species),
        upper = list(continuous = "cor"),
        lower = list(continuous = "points"),
        diag = list(continuous = "densityDiag")) +
  scale_color_manual(values = c("setosa" = "#E69F00", 
                                 "versicolor" = "#56B4E9", 
                                 "virginica" = "#009E73")) +
  scale_fill_manual(values = c("setosa" = "#E69F00", 
                                "versicolor" = "#56B4E9", 
                                "virginica" = "#009E73")) +
  theme_bw()

Note that you need both scale_color_manual() and scale_fill_manual() because different panel types use different aesthetics.

Selecting Specific Variables

With datasets containing many variables, showing all pairwise relationships becomes impractical. A 10-variable pair plot contains 100 panels and becomes difficult to interpret.

Select specific variables of interest:

# Focus on specific measurements
ggpairs(iris, 
        columns = c("Sepal.Length", "Petal.Length", "Petal.Width"),
        aes(color = Species, alpha = 0.6))

You can also mix numeric column indices and names:

# Select by position and name
ggpairs(iris, 
        columns = c(1, 3, 4, 5),  # Sepal.Length, Petal.Length, Petal.Width, Species
        aes(color = Species))

For datasets with many features, consider creating multiple focused pair plots rather than one overwhelming visualization:

# Morphological measurements
ggpairs(iris, columns = c(1, 2, 5), aes(color = Species))

# Petal characteristics
ggpairs(iris, columns = c(3, 4, 5), aes(color = Species))

This approach makes each visualization more digestible and allows you to tell specific stories about different feature groups.

Advanced Customization with Custom Functions

For maximum control, define custom functions for specific panels. This lets you add regression lines, display custom statistics, or create entirely novel visualizations.

# Custom function to show correlation with significance
my_cor <- function(data, mapping, method = "pearson", ...) {
  x <- eval_data_col(data, mapping$x)
  y <- eval_data_col(data, mapping$y)
  
  cor_test <- cor.test(x, y, method = method)
  cor_value <- cor_test$estimate
  p_value <- cor_test$p.value
  
  cor_label <- paste0("r = ", round(cor_value, 2), 
                     "\np = ", format.pval(p_value, digits = 2))
  
  ggplot(data = data, mapping = mapping) +
    annotate("text", x = mean(range(x)), y = mean(range(y)),
             label = cor_label, size = 4) +
    theme_void()
}

# Custom scatter plot with regression line
my_scatter <- function(data, mapping, ...) {
  ggplot(data = data, mapping = mapping) +
    geom_point(alpha = 0.5, size = 1) +
    geom_smooth(method = "lm", se = TRUE, color = "blue", linewidth = 0.5)
}

# Apply custom functions
ggpairs(iris,
        columns = 1:4,
        upper = list(continuous = my_cor),
        lower = list(continuous = my_scatter),
        diag = list(continuous = wrap("densityDiag", alpha = 0.5)))

This creates pair plots with statistical significance tests in the upper triangle and regression lines in the lower triangle. Custom functions give you complete control over what information to display and how to present it.

Performance Considerations and Alternatives

Pair plots scale poorly with large datasets. A pair plot with n variables creates n² panels, and each scatter plot potentially displays thousands of points. With 100,000 rows and 10 variables, you’re rendering 1 million points across 100 panels.

For large datasets, sample your data first:

# Sample 1000 rows for visualization
set.seed(42)
sampled_data <- iris[sample(nrow(iris), min(1000, nrow(iris))), ]
ggpairs(sampled_data, columns = 1:4, aes(color = Species))

Alternatively, use hexbin plots for the lower triangle:

ggpairs(large_dataset,
        columns = 1:5,
        lower = list(continuous = "hex"),
        upper = list(continuous = "cor"))

For truly massive datasets, consider computing correlations separately and visualizing only the correlation matrix:

library(corrplot)
cor_matrix <- cor(iris[, 1:4])
corrplot(cor_matrix, method = "color", type = "upper", 
         order = "hclust", addCoef.col = "black")

Base R’s pairs() function is faster but less flexible:

pairs(iris[, 1:4], 
      col = iris$Species,
      pch = 19,
      lower.panel = NULL)

Use pairs() when you need quick visualizations and don’t require ggplot2’s aesthetic system. Use ggpairs() when you need publication-quality graphics or complex customization.

The choice between these approaches depends on your dataset size, computational resources, and whether you’re doing quick exploration or creating final visualizations. For exploratory analysis, speed matters more than perfection. For reports and publications, invest time in customization.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.