Note | Vincenzo Coia | Statistician, combining research and practice for probabilistic and risk modelling in the earth sciences.

Contour Plots with ggplot2

Thu, 10 Jul 2025 00:00:00 +0000

Contour lines, or isolines, are curves outlining the x-y coordinates of a 3D surface having a given elevation. It’s like cutting the tops of mountains off at set elevations, and tracing the shapes formed by the new (flat) mountain tops.

This tutorial introduces two ways to make contour plots using ggplot2, for two different purposes. First, load the tidyverse (which includes ggplot2).

library(tidyverse)
theme_set(theme_minimal())

Method 1: General Contour Plots: `geom_contour()`

Using this method, you can make a contour plot of any bivariate function.

Basics

To demonstrate, let’s use the bivariate function $$f(x, y) = x ^ 2 + \sin(y)$$ over the rectangle $-2<x<2$ and $-5<y<5$.

f <- function(x, y) x ^ 2 + sin(y)

Make a grid over the rectangle in a long-form data frame. It must be a grid – geom_contour() won’t work otherwise. The expand_grid() function in the tidyverse (or expand.grid() in base R) is handy for this, filling in all combinations of its input. Our grid will be $100 \times 100$ points.

## Make a data frame with columns x and y defining a 100x100 grid.
x <- seq(-2, 2, length.out = 100)
y <- seq(-5, 5, length.out = 100)
dat <- expand_grid(x = x, y = y)
## Inspect data frame.
dat

## # A tibble: 10,000 × 2
##        x     y
##    <dbl> <dbl>
##  1    -2 -5   
##  2    -2 -4.90
##  3    -2 -4.80
##  4    -2 -4.70
##  5    -2 -4.60
##  6    -2 -4.49
##  7    -2 -4.39
##  8    -2 -4.29
##  9    -2 -4.19
## 10    -2 -4.09
## # ℹ 9,990 more rows

Evaluate the function at each of the grid points, forming a third column that we’ll call z.

## Add a column containing the function evaluation.
dat <- mutate(dat, z = f(x, y))
## Inspect data frame.
dat

## # A tibble: 10,000 × 3
##        x     y     z
##    <dbl> <dbl> <dbl>
##  1    -2 -5     4.96
##  2    -2 -4.90  4.98
##  3    -2 -4.80  5.00
##  4    -2 -4.70  5.00
##  5    -2 -4.60  4.99
##  6    -2 -4.49  4.98
##  7    -2 -4.39  4.95
##  8    -2 -4.29  4.91
##  9    -2 -4.19  4.87
## 10    -2 -4.09  4.81
## # ℹ 9,990 more rows

Use this data frame with ggplot2’s geom_contour(). The x and y aesthetics should be the two grid columns (also called x and y in our data frame), and the z aesthetic should be mapped to the column with the evaluated function (also called z in our data frame).

## Add a `geom_contour()` layer with aesthetics x, y, and z.
ggplot(dat, aes(x, y)) +
  geom_contour(aes(z = z))

Grid Size

The $100 \times 100$ grid used above makes for a smooth surface, and only requires 10,000 function evaluations.

x <- seq(-2, 2, length.out = 10)
y <- seq(-5, 5, length.out = 10)
expand_grid(x = x, y = y) %>% 
    mutate(z = f(x, y)) %>% 
    ggplot(aes(x, y)) +
    geom_contour(aes(z = z)) +
    theme(axis.title.y = element_text(angle = 0, vjust = 0.5))

Example using the `volcano` data

R comes with a dataset containing the altitudes of a volcano, Maunga Whau (Mt Eden), stored in the datasets variable volcano. You’ll notice that the dataset is literally a grid of $87 \times 61$ altitudes – here are the first six rows and columns:

volcano[1:6, 1:6]

##      [,1] [,2] [,3] [,4] [,5] [,6]
## [1,]  100  100  101  101  101  101
## [2,]  101  101  102  102  102  102
## [3,]  102  102  103  103  103  103
## [4,]  103  103  104  104  104  104
## [5,]  104  104  105  105  105  105
## [6,]  105  105  105  106  106  106

If you’d like, you can take a look at a 3D rendering of the volcano using the rgl package’s surface3d() function. The code for doing this is directly in the documentation of the surface3d() function.

In order to make a contour plot with ggplot2’s geom_contour(), we’ll first need to turn this into a tidy data frame with three columns. You could use as.vector(volcano) to get a vector of altitudes, and line that up with a grid laid out as two columns, but I’m not going to take any chances here, so I’ll opt to use pivot_longer(). We don’t know much about the latitude and longitude, so their values are arbitrary.

(volcano_tidy <- as_tibble(volcano, .name_repair = "universal") %>% 
    mutate(latitude = 1:n()) %>% 
    pivot_longer(!latitude, names_to = "longitude", values_to = "altitude"))

## # A tibble: 5,307 × 3
##    latitude longitude altitude
##       <int> <chr>        <dbl>
##  1        1 ...1           100
##  2        1 ...2           100
##  3        1 ...3           101
##  4        1 ...4           101
##  5        1 ...5           101
##  6        1 ...6           101
##  7        1 ...7           101
##  8        1 ...8           100
##  9        1 ...9           100
## 10        1 ...10          100
## # ℹ 5,297 more rows

Fix up the longitude (taking the negative to reverse the order, because data are provided as east to west):

(volcano_tidy <- volcano_tidy %>% 
    mutate(longitude = longitude %>% 
               str_remove("[\\.]{3}") %>%
               as.numeric() %>% 
               `-`()))

## # A tibble: 5,307 × 3
##    latitude longitude altitude
##       <int>     <dbl>    <dbl>
##  1        1        -1      100
##  2        1        -2      100
##  3        1        -3      101
##  4        1        -4      101
##  5        1        -5      101
##  6        1        -6      101
##  7        1        -7      101
##  8        1        -8      100
##  9        1        -9      100
## 10        1       -10      100
## # ℹ 5,297 more rows

Now the contour plot comes for free:

ggplot(volcano_tidy, aes(longitude, latitude)) +
    geom_contour(aes(z = altitude)) +
    theme_void()

But, you can’t tell that the inner circles actually represent a hole (a caldera), not a peak. Let’s add colour by mapping the ..height.. “variable” to the colour aesthetic of geom_contour(). This will also create a legend for altitude.

ggplot(volcano_tidy, aes(longitude, latitude)) +
    geom_contour(aes(z = altitude, colour = ..level..)) +
    theme_void() +
    scale_color_continuous("Altitude")

## Warning: The dot-dot notation (`..level..`) was deprecated in ggplot2 3.4.0.
## ℹ Please use `after_stat(level)` instead.
## This warning is displayed once every 8 hours.
## Call `lifecycle::last_lifecycle_warnings()` to see where this warning was
## generated.

We can somewhat tell that the highest point is within the lightest blue area, just below the caldera. But, we would get a better sense of the terrain by adding more contour lines. You can use the bins argument in the geom_contour() function to indicate the number of altitudes for which to draw contours, or binwidth to specify a range of altitudes. Let’s make 20 contours with bins = 20:

ggplot(volcano_tidy, aes(longitude, latitude)) +
    geom_contour(aes(z = altitude, colour = ..level..), bins = 20) +
    theme_void() +
    scale_color_continuous("Altitude")

Method 2: Approximate a bivariate density: `geom_density2d()`

This method approximates a bivariate density from data.

First, recall how this is done in the univariate case. A little kernel function (like a shrunken bell curve) is placed over each data point, and these are added together to get a density estimate:

set.seed(373)
x <- rnorm(1000)
tibble(x = x) %>% 
    ggplot(aes(x)) +
    geom_density()

We can do the same thing to get a bivariate density, except with little bivariate kernel functions (like shrunken bivariate Gaussian densities). But, we can’t just simply put “density height” on the vertical axis – we need that for the second dimension. Instead, we can use contour plots.

This is the contour plot that ggplot2’s geom_density2d() does: builds a bivariate kernel density estimate (based on data), then makes a contour plot out of it:

y <- rnorm(1000)
tibble(x = x, y = y) %>% 
    ggplot(aes(x, y)) + 
    geom_density2d() +
    theme(axis.title.y = element_text(angle = 0, vjust = 0.5))

Based on context (this is a density), we know that this is a “hill” and not a “hole”. If you were to start at some point at the “bottom” of the hill, the steepest way up would be perpendicular to the contours. The highest point on the hill is within the middle-most circle.

Communicating Data

Tue, 15 Sep 2020 00:00:00 +0000

ggplot2 tutorial

Sat, 03 Mar 2018 00:00:00 +0000

Two youtube videos (embed)

JAGS Tutorial

Sat, 03 Mar 2018 00:00:00 +0000

JAGS is a language that allows you to run Bayesian analyses. It gets at the posterior by generating samples based on the posterior and statistical model.

You’ll need to download and install JAGS. You can interact with JAGS through one of three R packages:

runjags (recommended for this course)
- Model written as a single string in R; possibly also allows you to input from file.
- Quick-start guide vignette: vignette("quickjags", package="runjags")
- Full user guide vignette: vignette("UserGuide", package="runjags")
rjags (sample code here)
- Model read in from plain text file.
R2jags
- this is dependent on R2winbugs, which I find doesn’t work well outside of Windows machines, so I’m more hesitant to use this package.
- Model written in R as a function, but using JAGS language; or inputted from file.

Also, the coda package is useful for working with the output of at least runjags.

About the JAGS language:

Generates samples of parameters based on the prior and statistical model.
Need to specify which parameters you want to include in the output (aka “track” or “monitor”).
Specify probability distributions similarly to R, except:
- Draw samples using calls like dexp and dnorm, not rexp and rnorm.
- The JAGS version of rnorm uses the precision (=1/variance) instead of standard deviation. The documentation of JAGS code is not as nice as R. You have to look things up from a table-of-contents-style search from this document. Page 29 shows the aliases for various distributions.

For this week’s lab assignment (3), you’ll only be using it to generate observations from a distribution. Let’s generate data from a N(0,2) distribution (that is, variance=2), and ignore the warning messages for this week.

library(runjags)
my_model <- "
model{
    # This is a comment.
    theta ~ dnorm(0, 1/2)
}
"
fit <- run.jags(my_model, monitor = "theta", n.chains = 1, sample = 1000)

## Calling the simulation...
## Welcome to JAGS 4.3.0 on Mon Aug 26 23:18:23 2024
## JAGS is free software and comes with ABSOLUTELY NO WARRANTY
## Loading module: basemod: ok
## Loading module: bugs: ok
## . . Compiling model graph
##    Resolving undeclared variables
##    Allocating nodes
## Graph information:
##    Observed stochastic nodes: 0
##    Unobserved stochastic nodes: 1
##    Total graph size: 5
## . Initializing model
## . Adaptation skipped: model is not in adaptive mode.
## . Updating 4000
## -------------------------------------------------| 4000
## ************************************************** 100%
## . . Updating 1000
## -------------------------------------------------| 1000
## ************************************************** 100%
## . . . . Updating 0
## . Deleting model
## . 
## Note: the model did not require adaptation
## Simulation complete.  Reading coda files...
## Coda files loaded successfully
## Calculating summary statistics...
## Finished running the simulation

theta <- coda::as.mcmc(fit)
head(theta)

## Markov Chain Monte Carlo (MCMC) output:
## Start = 5001 
## End = 5007 
## Thinning interval = 1 
##          theta
## 5001 -0.107460
## 5002 -2.470150
## 5003 -0.573465
## 5004  1.315170
## 5005 -2.341930
## 5006 -1.163790
## 5007 -1.032190

plot(theta)

More sample code

library(tidyverse)

## Warning: package 'tidyverse' was built under R version 4.1.2

## Warning: package 'tibble' was built under R version 4.1.2

## Warning: package 'tidyr' was built under R version 4.1.2

## Warning: package 'readr' was built under R version 4.1.2

## Warning: package 'purrr' was built under R version 4.1.2

## Warning: package 'dplyr' was built under R version 4.1.2

## Warning: package 'stringr' was built under R version 4.1.2

## Warning: package 'forcats' was built under R version 4.1.2

## Warning: package 'lubridate' was built under R version 4.1.2

## ── Attaching core tidyverse packages ──────────────────────── tidyverse 2.0.0 ──
## ✔ dplyr     1.1.2     ✔ readr     2.1.4
## ✔ forcats   1.0.0     ✔ stringr   1.5.0
## ✔ ggplot2   3.4.4     ✔ tibble    3.2.1
## ✔ lubridate 1.9.2     ✔ tidyr     1.3.0
## ✔ purrr     1.0.1     
## ── Conflicts ────────────────────────────────────────── tidyverse_conflicts() ──
## ✖ tidyr::extract() masks runjags::extract()
## ✖ dplyr::filter()  masks stats::filter()
## ✖ dplyr::lag()     masks stats::lag()
## ℹ Use the conflicted package (<http://conflicted.r-lib.org/>) to force all conflicts to become errors

library(runjags)
n <- 50
dat <- tibble(x = rnorm(n),
              y = x + rnorm(n))
jagsdat <- c(as.list(dat), n = nrow(dat))
model <- "model{
    for (i in 1:n) {
        y[i] ~ dnorm(beta*x[i], tau)
    }
    tau <- pow(sigma, -2)
	sigma ~ dunif(0, 100)
    beta ~ dnorm(0, 0.001)
}"
foo <- run.jags(
    model = model, 
    monitor = c("beta0", "beta1", "sigma"), 
    data = jagsdat
)

## Warning: No initial value blocks found and n.chains not specified: 2 chains were
## used

## Warning: No initial values were provided - JAGS will use the same initial values
## for all chains

## Calling the simulation...
## Welcome to JAGS 4.3.0 on Mon Aug 26 23:18:26 2024
## JAGS is free software and comes with ABSOLUTELY NO WARRANTY
## Loading module: basemod: ok
## Loading module: bugs: ok
## . . Reading data file data.txt
## . Compiling model graph
##    Resolving undeclared variables
##    Allocating nodes
## Graph information:
##    Observed stochastic nodes: 50
##    Unobserved stochastic nodes: 2
##    Total graph size: 159
## . Initializing model
## . Adapting 1000
## -------------------------------------------------| 1000
## ++++++++++++++++++++++++++++++++++++++++++++++++++ 100%
## Adaptation successful
## . Updating 4000
## -------------------------------------------------| 4000
## ************************************************** 100%
## . Failed to set trace monitor for beta0
## Variable beta0 not found
## . Failed to set trace monitor for beta1
## Variable beta1 not found
## . . Updating 10000
## -------------------------------------------------| 10000
## ************************************************** 100%
## . . . . . Updating 0
## . Deleting model
## . 
## Simulation complete.  Reading coda files...
## Coda files loaded successfully
## Calculating summary statistics...
## Calculating the Gelman-Rubin statistic for 1 variables....
## Finished running the simulation

plot(coda::as.mcmc(foo))

## Warning in as.mcmc.runjags(foo): Combining the 2 mcmc chains together

Generalized Additive Models

Thu, 01 Feb 2018 00:00:00 +0000

Generalized Additive Models

To fit a GAM in R, we could use:

the function gam in the mgcv package, or
the function gam in the gam package.

Differences between the two functions are discussed in the “Details” section of the gam documentation in the mgcv package. Choose one, but don’t load both! mgcv tends to be updated more frequently, and is generally more flexible (compare the Index pages), so that’s what is used in this tutorial. But the gam package has similar workings.

The gam function works similarly to other regression functions, but the formula specification is different. Let’s go through different formula specifications, doing regression on the mtcars dataset in R.

The formula mpg ~ disp + wt gives you a linear model. It indicates that disp and wt both enter the model in a linear fashion.

library(tidyverse)
library(broom)
library(mgcv)
fit1 <- gam(mpg ~ disp + wt, data = mtcars)
fit2 <- lm(mpg ~ disp + wt, data = mtcars)
summary(fit1)

## 
## Family: gaussian 
## Link function: identity 
## 
## Formula:
## mpg ~ disp + wt
## 
## Parametric coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept) 34.96055    2.16454  16.151 4.91e-16 ***
## disp        -0.01773    0.00919  -1.929  0.06362 .  
## wt          -3.35082    1.16413  -2.878  0.00743 ** 
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## 
## R-sq.(adj) =  0.766   Deviance explained = 78.1%
## GCV = 9.3863  Scale est. = 8.5063    n = 32

summary(fit2)

## 
## Call:
## lm(formula = mpg ~ disp + wt, data = mtcars)
## 
## Residuals:
##     Min      1Q  Median      3Q     Max 
## -3.4087 -2.3243 -0.7683  1.7721  6.3484 
## 
## Coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept) 34.96055    2.16454  16.151 4.91e-16 ***
## disp        -0.01773    0.00919  -1.929  0.06362 .  
## wt          -3.35082    1.16413  -2.878  0.00743 ** 
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Residual standard error: 2.917 on 29 degrees of freedom
## Multiple R-squared:  0.7809,	Adjusted R-squared:  0.7658 
## F-statistic: 51.69 on 2 and 29 DF,  p-value: 2.744e-10

Notice that the coefficient estimates are the same.

To make a term non-parametric, wrap the s() function around the term (for splines; comes with the mgcv package). The gam package also has a lo function, for loess smoothing.

fit3 <- gam(mpg ~ s(disp) + s(wt), data = mtcars)
summary(fit3)

## 
## Family: gaussian 
## Link function: identity 
## 
## Formula:
## mpg ~ s(disp) + s(wt)
## 
## Parametric coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  20.0906     0.3429   58.59   <2e-16 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Approximate significance of smooth terms:
##           edf Ref.df     F  p-value    
## s(disp) 6.263  7.386 6.373 0.000271 ***
## s(wt)   1.000  1.000 4.015 0.056497 .  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## R-sq.(adj) =  0.896   Deviance explained = 92.1%
## GCV = 5.0715  Scale est. = 3.762     n = 32

Now, each predictor enters the model in a non-parametric, additive form. The nonparametric functions can be accessed by calling plot(). For documentation, see ?plot.gam. Let’s plot the “bivariate” scatterplots behind these curves too (these bivariate data actually use partial residuals).

plot(fit3, residuals = TRUE)

Looks like the “weight” variable (wt) is quite linear. We can let it be linear, while the disp variable remains nonparametric. “Wiggliness” of the smoothed fit can be controlled through the k argument of the s() function, but this is chosen in a “smart” way by default.

fit4 <- gam(mpg ~ s(disp, k = 3) + wt, data = mtcars)
summary(fit4)

## 
## Family: gaussian 
## Link function: identity 
## 
## Formula:
## mpg ~ s(disp, k = 3) + wt
## 
## Parametric coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)  31.1110     3.1336   9.928  1.1e-10 ***
## wt           -3.4254     0.9649  -3.550  0.00138 ** 
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Approximate significance of smooth terms:
##          edf Ref.df     F  p-value    
## s(disp) 1.93  1.995 9.724 0.000831 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## R-sq.(adj) =  0.839   Deviance explained = 85.4%
## GCV =  6.659  Scale est. = 5.8413    n = 32

plot(fit4, residuals = TRUE)

You can even combine predictors into a common smooth function:

fit5 <- gam(mpg ~ s(disp, qsec) + wt, data = mtcars)
summary(fit5)

## 
## Family: gaussian 
## Link function: identity 
## 
## Formula:
## mpg ~ s(disp, qsec) + wt
## 
## Parametric coefficients:
##             Estimate Std. Error t value Pr(>|t|)    
## (Intercept)   32.181      4.340   7.415 1.83e-07 ***
## wt            -3.758      1.345  -2.794   0.0105 *  
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## Approximate significance of smooth terms:
##                edf Ref.df     F p-value    
## s(disp,qsec) 7.634  9.694 5.353 0.00057 ***
## ---
## Signif. codes:  0 '***' 0.001 '**' 0.01 '*' 0.05 '.' 0.1 ' ' 1
## 
## R-sq.(adj) =  0.903   Deviance explained =   93%
## GCV = 5.0335  Scale est. = 3.5181    n = 32

For each, the predict() and residuals() functions work in the same old way, but let’s use the augment() function from the broom package instead, and make a residual plot:

augment(fit5, newdata = mtcars) %>% 
	mutate(Residuals = mpg - .fitted) %>% 
	ggplot(aes(.fitted, Residuals)) +
	geom_point() +
    geom_abline(intercept = 0, slope = 0, linetype = "dashed") +
    xlab("Prediction (mean)") +
	theme_minimal()

For their documentation, see ?predict.gam and ?residuals.gam.

Mixture distributions

Wed, 22 Feb 2017 00:00:00 +0000

UPDATE: For a clean implementation of mixture distributions, check out the distplyr R package.

This tutorial introduces the concept of a mixture distribution. We’ll look at a basic example first, using intuition, and then describe mixture distributions mathematically. See the very end for a summary of the learning points.

Intuition

Let’s start by looking at a basic experiment:

Flip a coin.
If the outcome is heads, generate a N(0,1) random variable. If the outcome is tails, generate a N(4,1) random variable. We’ll let $X$ denote the final result.

$X$ is a random variable with some distribution (spoiler: it’s a mixture distribution). Let’s perform the experiment 1000 times to get 1000 realizations of $X$, and make a histogram to get a sense of the distribution $X$ follows. To make sure the histogram represents an estimate of the density, we’ll make sure the area of the bars add to 1 (with the ..density.. option).

library(tidyverse)
set.seed(44)
X <- numeric(0)
coin <- integer(0)
for (i in 1:1000) {
    coin[i] <- rbinom(1, size = 1, prob = 0.5)  # flip a coin. 0=heads, 1=tails.
    if (coin[i] == 0) {   # heads
        X[i] <- rnorm(1, mean = 0, sd = 1)
    } else {           # tails
        X[i] <- rnorm(1, mean = 4, sd = 1)
    }
}
(p <- qplot(X, ..density.., geom = "histogram", bins = 30))

Let’s try to reason our way to figuring out the overall density. Keep in mind that this density (like all densities) is one curve. We’ll say we’ve succeeded at finding the density if our density is close to the histogram.

It looks like the histogram is made up of two normal distributions “superimposed”. These ought to be related to the N(0,1) and N(4,1) distributions, so to start, let’s plot these two Gaussian densities overtop of the histogram.

tibble(X = X) %>% 
    ggplot(aes(X)) +
    geom_histogram(aes(y = ..density..), bins = 30) +
    stat_function(fun = function(x) dnorm(x, mean = 0, sd = 1), 
                  mapping = aes(colour = "Heads")) +
    stat_function(fun = function(x) dnorm(x, mean = 4, sd = 1), 
                  mapping = aes(colour = "Tails")) +
    scale_color_discrete("Coin Flip")

Well, the two Gaussian distributions are in the correct location, and it even looks like they have the correct spread, but they’re too tall.

Something to note at this point: the two curves plotted above are separate (component) distributions. We’re trying to figure out the distribution of $X$ – which, again, is a single curve, and is estimated by the histogram. At this point, we only suspect that the distribution of $X$ is some combination of these two Gaussian distributions.

So, why are the Gaussian curves too tall? Because each one represents the distribution if we only ever flip either heads or tails (for example, the red distribution happens when we only ever flip heads). But since we flip heads half of the time, and tails half of the time, these probabilities (more accurately, densities) ought to be reduced by half. Let’s add these “semi” component distributions to the plot:

(p <- tibble(X = X) %>% 
     ggplot(aes(X)) +
     geom_histogram(aes(y = ..density..), bins = 30) +
     stat_function(fun = function(x) dnorm(x, mean = 0, sd = 1)*0.5, 
                   mapping = aes(colour = "Heads", linetype = "Semi")) +
     stat_function(fun = function(x) dnorm(x, mean = 4, sd = 1)*0.5, 
                   mapping = aes(colour = "Tails", linetype = "Semi")) +
     stat_function(fun = function(x) dnorm(x, mean = 0, sd = 1), 
                   mapping = aes(colour = "Heads", linetype = "Full")) +
     stat_function(fun = function(x) dnorm(x, mean = 4, sd = 1), 
                   mapping = aes(colour = "Tails", linetype = "Full")) +
     scale_color_discrete("Coin Flip") +
     scale_linetype_discrete("Distribution"))

Looks like they line up quite nicely!

But these two curves are still separate – we need one overall curve if we are to find the distribution of $X$. So we need to combine them somehow. It might look at first that we can just take the upper-most of the ‘semi’ curves (i.e., the maximum of the two), but looking in between the two curves reveals that the histogram is actually larger than either curve here. It turns out that the two ‘semi’ curves are added to get the final curve:

p + stat_function(fun = function(x) dnorm(x, mean = 0, sd = 1) * 0.5 + 
                      dnorm(x, mean = 4, sd = 1) * 0.5,
                  mapping = aes(linetype = "Full"))

The intuition behind adding the densities is that an outcome for $X$ comes from both components, so both contribute some density.

Even though the random variable $X$ is made up of two components, at the end of the day, it’s still overall just a random variable with some density. And like all densities, the density of $X$ is just one curve. But, this density happens to be made up of the components, as we’ll see next.

General Scenario

The two normal distributions from above are called component distributions. In general, we can have any number of these (not just two) to make a mixture distribution. And, instead of selecting the component distribution with coin tosses, they’re chosen according to some generic probabilities called the mixture probabilities.

In general, here’s how we make a mixture distribution with $K$ component Gaussian distributions with densities $\phi_1(x), \ldots, \phi_K(x)$:

Choose one of the $K$ components, randomly, with mixture probabilities $\pi_1, \ldots, \pi_K$ (which, by necessity, add to 1).
Generate a random variable from the selected component distribution. Call the result $X$.

Note: we can use more than just Gaussian component distributions! But this tutorial won’t demonstrate that.

That’s how we generate a random variable with a mixture distribution, but what’s its density? We can derive that by the law of total probability. Let $C$ be the selected component number; then the component distributions are actually the distribution of $X$ conditional on the component number. We get:

$$ f_X\left(x\right) = \sum_{k=1}^{K} f_{X|C}\left(x \mid c\right) P\left(C=c\right) = \sum_{k=1}^{K} \phi_k\left(x\right) \pi_k. $$

Notes:

The intuition described in the previous section matches up with this result. For $K=2$ components determined by a coin toss $(\pi_1=\pi_2=0.5),$ we have $$ f_X\left(x\right) = \phi\left(x\right)0.5 + \phi\left(x-4\right)0.5, $$ which is the black curve in the previous plot.
This tutorial works with univariate data. But mixture distributions can be multivariate, too. A $d$-variate mixture distribution can be made by replacing the component distributions with $d$-variate distributions. Just be sure to distinguish between the dimension of the data $d$ and the number of components $K$.
We could just describe a mixture distribution by its density, just like we can describe a normal distribution by its density. But, describing mixture distributions by its component distributions together with the mixture probabilities, we obtain an excellent interpretation of the mixture distribution. This interpretation is (it’s also called a data generating process): (1) randomly choose a component, and (2) generate from that component. This interpretation is useful for cluster analysis, because the data clusters can be thought of as being generated by the component distributions, and the proportion of data in each cluster is determined by the mixture probabilities.

Learning Points

A mixture distribution can be described by its mixing probabilities $\pi_1, \ldots, \pi_K$ and component distributions $\phi_1(x), \ldots, \phi_K(x)$.
A mixture distribution can also be described by a single density (like all continuous random variables).
- This density is a single curve if data are univariate; a single “surface” if the data are bivariate; and higher dimensional surfaces if the data are higher dimensional.
To get the density from the mixing probabilities and component distributions, we can use the formula indicated in the above section (based on the law of total probability).

Note | Vincenzo Coia | Statistician, combining research and practice for probabilistic and risk modelling in the earth sciences.

Contour Plots with ggplot2

Method 1: General Contour Plots: geom_contour()

Basics

Grid Size

Example using the volcano data

Method 2: Approximate a bivariate density: geom_density2d()

Communicating Data

ggplot2 tutorial

JAGS Tutorial

More sample code

Generalized Additive Models

Generalized Additive Models

Mixture distributions

Intuition

General Scenario

Notes:

Learning Points

Method 1: General Contour Plots: `geom_contour()`

Example using the `volcano` data

Method 2: Approximate a bivariate density: `geom_density2d()`