ggplot2 on Eric Cramer

Presenting a "Data Slide"

Mon, 19 Jun 2023 00:00:00 +0000

How to present a “data slide” in a scientific talk

As part of my PhD program, we are required to take a professional development class for scientists that focuses on the “soft” skills of being a successful scientist. We recently had a lecture on presenting our data, and I thought I would share some of my notes, impressions, and the project we were asked to do (preparing a singular slide to present data from an experiment).

Here are a few descriptions of the “cardinal rules.”

No “data dumping”.

Don’t just put data (raw or processed) on your slide. You need to contextualize it somehow.

“Data doesn’t speak for itself…you do.”

Determine your audience.

Think about your audience ahead of time. What will their backgrounds be? Are they in your field? Are they lay-persons? What will their needs be so you can best convey your ideas. This can be tricky. You need to tailor your content to match the level of familiarity and literacy of your audience to get your point across. This means spelling out acronyms, using images, simple graphs, and providing background when necessary.

Why is this important?

This one is simple. People will tune you out (eventually, but perhaps more quickly than otherwise) if you don’t tell them why they should listen to you.

Organization

Before you start your presentation, make an outline. When you present, you are trying to tell a story with a beginning (your question and its relevance), middle (your experiment, the data you collected), and end (results, graphs/figures). Craft your narrative and determine what evidence you need to support it at each point during your talk. You might end up with a bunch of little stories lined up end to end. If that’s the case, make sure you add summaries and overarching statements to tie it all together.

Visualization

Too complex to sum up appropriately here, and there are a million resources out there already anyway. I’m not going to reinvent the wheel here. My main takeaway from this lecture was the flow chart below, which I thought was a useful aid for determining which type of visualization best suits your data and message.

/ [pdf]

The other message I got was to try to think a little like a graphic designer, and to use gestalt principles from psychology to optimize a visualization for your particular message. Combine these with Weber’s Law - that some visual features are easier for us to perceive differences between. Essentially, we should encode our primary message using the features that we are naturally best at visually discriminating.

A few rules of thumb:

Always include plot title, axis titles, legend, and scale. Label everything.
Use features like color, angle, volume, etc. carefully (don’t use them simply to “jazz up” a graph!). If it isn’t there to make a point, don’t include it because it may otherwise mislead.
Make your figures accessible to everyone who views them. Prepare for colorblindness or differing levels of literacy.

Class presentation/project

For the class project, we needed to prepare a single “data slide” that we might include in a presentation about our work. We then presented the slide to our classmates. I’ve put my slide(s) here and code below. To put these into context, I decided to benchmark the k-means clustering algorithms included in the R standard library to see how their run time is affected by increasing the number of randomly initialized starts.

Code

library(palmerpenguins)
library(tidyverse)
library(ggthemes)
library(ggsci)
library(colorblindr)
library(cowplot)
library(knitr)
library(kableExtra)

peng <- penguins %>%
  na.omit() %>%
  select(bill_length_mm, bill_depth_mm, body_mass_g, flipper_length_mm) %>%
  scale()
peng_labels <- penguins %>%
  na.omit() %>%
  pull(species)


starts <- c(seq(1, 1e4, 50), 1e4) # number of starting positions
algs = c("Hartigan-Wong", "Lloyd", "Forgy", "MacQueen") # algorithms to try

myClus <- function(ns){
  return(kmeans(peng, 3, nstart = ns))
}

# function to run clustering for different algorithms
runClus <- function(alg, starts){
  n_starts <- length(starts)
  run_times <- rep(NULL, n_starts)
  converge_iters <- rep(NULL, n_starts)
  for(i in 1:n_starts){
    st <- system.time(replicate(1e3, myClus(n_starts[i])))
    start_time <- Sys.time()
    km <- kmeans(peng, 3, nstart = starts[i], algorithm = alg)
    end_time <- Sys.time()
    run_times[i] <- end_time - start_time
    converge_iters[i] <- km$iter
  }
  df <- data.frame(
    "run.times" = run_times
    , "convergence" = converge_iters
    , "algorithm" = rep(alg, n_starts)
  )
  return(df)
}

hw <- runClus(algs[1], starts)
ll <- runClus(algs[2], starts)
fo <- runClus(algs[3], starts)
mq <- runClus(algs[4], starts)

all_algs <- rbind(
  hw, ll, fo, mq
)

tol_palette <- c("#4477AA", "#CCBB44", "#228833", "#66CCEE", "#EE6677", "#AA3377", "#BBBBBB")
tol_palette2 <- c("#000000", "#DDAA33", "#BB5566", "#004488", "#FFFFFF")
n_runs <- nrow(filter(all_algs, algorithm == "Hartigan-Wong"))
alg_plot <- all_algs %>%
  add_column(
    n_starts = rep(starts, length(algs))
  ) %>%
  ggplot() +
  aes(
    x = n_starts
    , y = run.times
    , group = algorithm
    , color = algorithm
  ) +
  geom_line(
    size = 1
  ) +
  scale_color_manual(
    values = tol_palette2
  ) +
  labs(
    x = "Number of Starts"
    , y = "Run Time (s)"
    , title = "Number of Random Starts vs Algorithm Runtime"
    , subtitle = "The MacQueen algorithm outperforms other base R k-means"
    , color = "Algorithm"
  ) +
  theme_few() +
  theme(
    plot.title = element_text(size = 12)
    , plot.subtitle = element_text(size = 10)
    , panel.grid.major = element_line(color = "#DDDDDD", linetype = 2)
    , legend.position = "bottom"
    , axis.title = element_text(size = 10)
    , legend.title = element_text(size = 10)
  )

pca_res <- prcomp(peng, scale = FALSE)
pca_vals <- pca_res[["x"]] %>%
  data.frame() %>%
  add_column(
    label = peng_labels
  )

pca_plot <- pca_vals %>%
  ggplot() +
  aes(
    x = PC1
    , y = PC2
    , color = label
  ) +
  geom_point() +
  scale_color_manual(
    values = tol_palette
  ) +
  labs(
    x = "Principal Component 1"
    , y = "Principal Component 2"
    , title = "Palmer's Penguins"
    , color = "Species"
  ) +
  theme_few() +
  theme(
    panel.grid.major = element_line(color = "#DDDDDD", linetype = 2)
    , legend.position = "bottom"
    , plot.title = element_text(size = 12)
    , axis.title = element_text(size = 10)
    , legend.title = element_text(size = 10)
  )

prow <- plot_grid(
  pca_plot
  , alg_plot
  , labels = c('A', 'B')
  , label_size = 12
  , rel_widths = c(1.3, 2)
  )
# now add the title
title <- ggdraw() + 
  draw_label(
    "Which clustering algorithm is faster with the Palmer's Penguins dataset?",
    fontface = 'bold',
    x = 0,
    hjust = 0
  ) +
  theme(
    # add margin on the left of the drawing canvas,
    # so title is aligned with left edge of first plot
    plot.margin = margin(0, 0, 0, 7)
  )

figure <- plot_grid(
  title, prow,
  ncol = 1,
  # rel_heights values control vertical title margins
  rel_heights = c(0.1, 1)
)

Slide(s)

Citations/References/Credits/Links

Design and Deliver: Creating a great scientific presentation. Emily Hillhouse and Sarah Jacobs. Oregon Health & Science University. June 2023.
https://paldhous.github.io/ucb/2016/dataviz/week2.html
https://extremepresentation.typepad.com/files/choosing-a-good-chart-09.pdf

BMI 625 Final Project

Fri, 02 Jun 2023 00:00:00 +0000

Jelle’s Marble Runs and Marbula 1

Jelle’s Marble Runs is a YouTube channel that features a variety of marble racing events and competitions, with intricate tracks and colorful marbles. The channel exploded in worldwide popularity and received sponsorship from Last Week Tonight with John Oliver in 2020 when sports and spectatorship were oh hold during the Covid-19 pandemic.

Among their most exciting series is Marbula One, a racing championship modeled after the eponymous Formula 1 where marbles representing different teams compete in a series of high-speed (and adrenaline-pumping) races. Each race in Marbula One consists of two days of competition. On the first day (called “qualification”), marbles run (roll?) the track one at a time to see which goes fastest and set the order for the actual race. The second day of competition is the grand prix (race) itself.

Jelle’s Marble Runs feature engaging commentary and high-level production quality, which makes Marbula One and other events fun and exciting to watch. The channel has turned marbles into unexpected sports icons and created a uniquely entertaining experience for viewers of all ages.

The DATA

Description of the DATA you used (either given to you or where you found it, what unique characteristics of the data, what quantitative and qualitative information is in the data set, etc.)

The data set I used is the Marbula One Open Data Repository and a data set curated by Dr. Randal Olson. The data sets span several excel sheets, and the open data repository has a separate documentation file. I used two data sources because the data for the first season of Marbula One in the repository was not in tidy format, while Dr. Olson had already formatted the first season’s data.

To make this visual, I combined the table with information about each of the racing tracks used during the first season with Dr. Olson’s tidy-formatted file, and filtered it to isolate just the data recorded during the grand prixs (and not the qualifying runs - though it would be interesting to examine that relationship as well).

The graphic uses three of the variables from the data set:

The name of the race track (an un-ordered categorical variable).
The number of turns in the track (this is discrete, so treated I treated it as an ordered categorical variable).
The qualifying lap time on that track for each marble (continuous numeric variable).

Intended Audience

Description of the AUDIENCE you are aiming for (including more detail than simply saying “a biochemist”).

The intended audience is marble racing enthusiasts and Formula 1 fans who need something to tide them over until the next race (maybe also some curious physicists). This spans a variety of scientific or data-savvy different backgrounds, so it will be important to encode information clearly to avoid confusion.

Chart Type

Description of the TYPE of graph (e.g. Bar chart, Sankey Dendogram, etc).

I chose to use a raincloud plot to examine the distribution of lap times on different courses, and how that relates to the number of turns in the course.

Raincloud plots are hybrid charts consisting of a combination of box plots, [violin plots] (https://datavizcatalogue.com/methods/violin_plot.html), and jittered points/dot plots/scatter plots. The combination of a half-violin shape with adjacent points/dots is resembles a raincloud and gives the chart its name. The visual effect of a raincloud plot enhances traditional box plots through multiple modalities - namely by conveying distribution shapes and statistics while preserving raw data information. As a result, one of the greatest strengths of raincloud plots is data transparency.

Representation Description

Representation Description: What are you trying to show?

I started with the question: what is the relationship between the number of turns on a track and a marble’s lap time? And I had two thoughts about how to approach this:

Use the qualification lap times for each marble because there is no interference from other marbles on the race track. In theory this would be the most direct relationship.
This might be best answered using race lap times because more turns might cause more collisions between marbles, and thus be a more realistic description of a race.

I opted to do both since it is easy to do when the data are formatted the same way and the visualization is the same.

I also chose to use a raincloud plot because I wanted to show how the distribution of lap times for all of the marbles on any given track was shaped (normal, tailed, etc.), while preserving individual marble information. Both box plots and violin plots illustrate distributions, but do so by conveying some information and not all of it. They each have drawbacks and advantages, but in combination show a more complete picture.

I also wanted to show the individual average lap times for each marble as scatter points (the “rain drops”) for the sake of transparency and to highlight either high or low performing marbles (which may reveal a relationship between certain marbles and tracks). I think the next step for this graphic is to include interactivity or otherwise encode the identity for each marble visually.

How-To Read

How to read it & what to look for: How should a newbie to this graph approach interpreting it? What are the major highlights of the graph type?

Raincloud plots are designed to convey information from the big picture to the more minute details. I believe the best approach to reading these graphs is to start with the violin shape to get a sense of how points are distributed overall, then look at the box plot or central tendencies, and end with the individual data points. Examining the points (“rain drops”) as the last part helps to identify individual relationships in the context of the whole.

Presentation Choices

Presentation: address how you are using annotation, color, and general composition (e.g. how are things arranged, scale, etc.)

My first step was to determine the axes by encoding the number of turns in the track as one axis and the average lap time as the other. I chose to represent the number of turns as a discrete ordinal variable (because it was non-continuous). Several of the tracks have the same number of turns, so I used color to encode the identity of each track.

Methods (or “How I Built It”)

How I created it: Methods section (see point 1: all relevant code should be included); additionally, include a bit about the process. Please include an early draft of your visualization (it might be a completely different), and why you changed it/what you tweaked to get to your final visualization.

I started by loading the data.

dir_stem <- "content/post/2023-06-02-bmi-625-final-project/"
s1_results <- read_csv(here(paste0(dir_stem, "data/jelles-marble-racing-marbula-one.csv"))) %>%
  clean_names()

s1_tracks <- read_csv(here(paste0(dir_stem, "data/m1-track-stats.csv"))) %>%
  clean_names() %>%
  filter(season == 1)

Then I did a little bit of wrangling to merge the data sets and convert some of the variables to different types. I also separated the qualifying lap information from the actual grand prix race data.

s1_tracks_sub <- s1_tracks %>%
  select(track, turns, avg_lap_time)

s1_results <- s1_results %>%
  mutate(site = if_else(str_detect(site, "Hive"), "Hive Drive", site)) %>%
  left_join(
    s1_tracks_sub
    , by = join_by(site == track)
  ) %>%
  mutate(
    site = factor(site)
    , marble_name = factor(marble_name)
    , team_name = factor(team_name)
    , avg_time_lap_log = log10(avg_time_lap)
  )

s1_gps <- s1_results %>%
  filter(str_detect(race, "R"))
s1_quals <- s1_results %>%
  filter(str_detect(race, "Q"))

Start with a scatter plot of number of turns vs. lap time.

`1`	`ggplot(s1_quals, aes(turns, time_s)) + geom_point()`

There is actually a fair amount of variability among lap times, with clusters around certain times. Could there be a relationship between the number of turns and the distribution of lap times? Also, some of the race tracks have the same number of turns, and we cannot determine which is which from this graph alone. So I will encode that information with color.

s1_quals %>%
  ggplot() +
  aes(
    x = turns
    , y = time_s
    , fill = site
  ) +
  geom_boxplot()

The boxplots give us a numeric summary for the distribution of the points, but different shapes of point distributions can yield the same boxplot. So I will add a violin plot to clarify the shape of how the points are distributed. Also, the turns variable is not really continuous, so I will treat it as an ordered categorical variable.

s1_quals %>%
  mutate(turns = factor(turns)) %>%
  ggplot() +
  aes(
    x = turns
    , y = time_s
    , fill = site
  ) +
  geom_violin() +
  geom_boxplot(
    alpha = 0
  )

This gives a good idea of how the lap times are distributed both in terms of shape and numerically. But we may also be interested in the individual points themselves, for example, to see if a particular marble is a high or low performer. A raincloud plot would combine all three of these elements.

quals_plot <- s1_quals %>%
  mutate(turns = factor(turns)) %>%
  ggplot() +
  aes(
    x = turns
    , y = avg_time_lap
    , fill = site
  ) +
  ggdist::stat_halfeye(
    adjust = 0.5
    , width = 0.75
    , .width = c(0.5, 0.95)
    , justification = -0.2
    , point_colour = NA
    , alpha = 0.8
  ) + 
  ggdist::stat_dots(
    side = "left"
    , justification = 1.1
    , binwidth = 0.25
  ) +
  coord_cartesian(
    clip = "off"
  ) +
  coord_flip() +
  scale_y_continuous(
    expand=c(0.1, 0.1)
  ) +
  scale_x_discrete(
    expand=c(0.1, 0.1)
  ) +
  labs(
    x = "Turns in Track"
    , y = "Average Lap Time (ms)"
    , title = "Lap Time Distribution in Relation to Number of Turns in Track"
    , fill = "Grand Prix Track"
  ) +
  ggthemes::theme_few() +
  theme(
    plot.title = element_text(hjust = 0.5)
  )
quals_plot

It would be interesting to see how the individual champion of the first season of Marbula One performed on this plot. I will highlight the winner (Speedy of the Savage Speeders) with a red dot.

set.seed(123)
quals_plot <- s1_quals %>%
  mutate(
    turns = factor(turns)
    , s1_winner = if_else(marble_name == "Speedy", "Champion", "")
  ) %>%
  ggplot() +
  aes(
    x = turns
    , y = avg_time_lap
    , fill = site
  ) +
  ggdist::stat_halfeye(
    adjust = 0.5
    , width = 0.75
    , .width = c(0.5, 0.95)
    , justification = -0.2
    , point_colour = NA
    , alpha = 0.8
  ) + 
  ggdist::stat_dots(
    side = "left"
    , justification = 1.1
    , binwidth = 0.25
    , aes(color = s1_winner)
  ) +
  coord_cartesian(
    clip = "off"
  ) +
  coord_flip() +
  scale_y_continuous(
    expand=c(0.1, 0.1)
  ) +
  scale_x_discrete(
    expand=c(0.1, 0.1)
  ) +
  scale_color_manual(
    values = c("black", "red")
  ) +
  labs(
    x = "Turns in Track"
    , y = "Average Lap Time (ms)"
    , title = "Lap Time Distribution in Relation to Number of Turns in Track"
    , fill = "Grand Prix Track"
    , caption = "*The marked dot is Speedy, the champion of season one of Marbula One"
    , subtitle = "Based on lap time during pre-race qualification"
  ) +
  guides(
    color = "none"
  ) +
  ggthemes::theme_few() +
  theme(
    plot.title = element_text(hjust = 0.5)
  )
quals_plot

Then put the finishing touches on the graphic to make the color scheme colorblind-friendly and use fonts that evoke a racing theme.

# adding choice fonts
font_add_google("Righteous") # Righteous is bold and evokes a racing theme...
font_add_google("Lato")
showtext_auto()

# changing color scheme to Tol to be colorblind friendly
tol <- c("#332288", "#117733", "#88CCEE", "#CC6677", "#44AA99", "#AA4499", "#DDCC77", "#882255")

# setting ggplot2 options
# options(ggplot2.discrete.colour = okabe)
# options(ggplot2.discrete.fill = okabe)

# my marble racing theme...
marble_theme <- theme(
    plot.title = element_text(family = "Righteous")
    , axis.title = element_text(family = "Lato")
    , legend.title = element_text(family = "Lato")
    , legend.text = element_text(family = "Sans")
  )

quals_plot + 
  scale_fill_manual(
  values = tol
) + marble_theme

Citations and Resources

This project was presented in class on 2023-06-05. Slides here

A simple Shiny app for visualizing F1 data (Lab 7)

Thu, 25 May 2023 00:00:00 +0000

From Medicine to Formula 1

Around the time I started medical school, I became interested in longevity science and the emerging field within medicine. One of the physicians carving out this new niche in the profession is Dr. Peter Attia, whose practice specializes in increasing a patient’s healthspan and preparing patients for a “Centenarian Olympics.”" After listening to this episode of Peter Attia’s podcast The Drive (in which he interviews Dr. Luke Bennett, team doctor for Mercedes), I thought I would check out the show Drive to Survive on Netflix.

As part of the BMI 625 course at OHSU we needed to build a R Shiny application that wrangled and visualized a data set of our choice. Given my new interest in Formula 1, thought it would be interesting to see what the expected points might be for any team and driver during any race weekend - basically what is the average number of points a constructor or driver scores per grand prix. Thankfully, I didn’t need to do too much data scraping thanks to GitHub user UpperCase78. Please check out their repo to see the underlying data.

This analysis is an overly simple way to break down a complex sport like F1, but I think it was a good start and got me thinking about more downstream analyses I could do (breakdowns by track, for example). I might continue to work on this Shiny app further by adding more nuanced data sets and complex analyses.

You can check out the Shiny app here or below.

Data Wrangling

For those interested, here is how I cleaned up the data and calculated points per grand prix for drivers and constructors in R.

# 2013-2018
f1_2013 <- read_csv("data/PreviousSeasons/Formula1_2013season_raceResults.csv") %>%
  mutate(Year = 2013)
f1_2014 <- read_csv("data/PreviousSeasons/Formula1_2014season_raceResults.csv") %>%
  mutate(Year = 2014)
f1_2015 <- read_csv("data/PreviousSeasons/Formula1_2015season_raceResults.csv") %>%
  mutate(Year = 2015)
f1_2016 <- read_csv("data/PreviousSeasons/Formula1_2016season_raceResults.csv") %>%
  mutate(Year = 2016)
f1_2017 <- read_csv("data/PreviousSeasons/Formula1_2017season_raceResults.csv") %>%
  mutate(Year = 2017)
f1_2018 <- read_csv("data/PreviousSeasons/Formula1_2018season_raceResults.csv") %>%
  mutate(Year = 2018)

# 2019
race2019 <- read_csv("data/formula1_2019season_raceResults.csv") %>%
  mutate(Year = 2019)

# 2020
race2020 <- read_csv("data/formula1_2020season_raceResults.csv") %>%
  mutate(Year = 2020)

# 2021
race2021 <- read_csv("data/formula1_2021season_raceResults.csv") %>%
  mutate(Year = 2021)

# 2022
race2022 <- read_csv("data/Formula1_2022season_raceResults.csv") %>%
  mutate(Year = 2022)

varnames <- c("Track", "Driver", "Team", "Points", "Fastest Lap", "Year")

f1_data_1 <- rbind(
  f1_2013
  , f1_2014
  , f1_2015
  , f1_2016
  , f1_2017
  , f1_2018
) %>%
  select(varnames)

f1_data_2 <- rbind(
  race2019
  , race2020
) %>%
  select(varnames)

f1_data_3 <- rbind(
  race2021
  , race2022
) %>%
  select(varnames)

f1_data <- rbind(
  f1_data_1
  , f1_data_2
  , f1_data_3
) %>%
  group_by(Year, Driver) %>%
  mutate(driver_ppgp = round(sum(Points)/n(), 2)) %>%
  ungroup() %>%
  group_by(Year, Team) %>%
  mutate(team_ppgp = round(sum(Points)/n(), 2)) %>%
  ungroup() %>%
  mutate(Latest_Team_Name = Team)

# need to collapse the teams based on name changes...otherwise constructor 
# visualizations become unusable.
# Using the latest available team name based on information from:
# https://wtf1.com/post/these-are-all-the-f1-team-changes-in-the-last-decade/

f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Renault")] <- "Alpine"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Mercedes")] <- "Mercedes"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Ferrari")] <- "Ferrari"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Red Bull")] <- "Red Bull"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Toro Rosso")] <- "AlphaTauri"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "AlphaTauri")] <- "AlphaTauri"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "STR Ferrari")] <- "AlphaTauri"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Sauber")] <- "Alfa Romeo"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Alfa Romeo")] <- "Alfa Romeo"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Williams")] <- "Williams"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Force India")] <- "Aston Martin"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Aston Martin")] <- "Aston Martin"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Racing Point")] <- "Aston Martin"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "McLaren")] <- "McLaren"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Lotus")] <- "Lotus"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Haas")] <- "Haas"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Marussia")] <- "Manor"
f1_data$Latest_Team_Name[str_detect(f1_data$Team, "Caterham")] <- "Caterham"

# write out
write_csv(f1_data, "f1_data.csv")

This post was excerpted from Lab 7 of BMI 625

BMI 625 Graph Exploration and Brief #1

Wed, 10 May 2023 00:00:00 +0000

Candlestick Chart (aka Japanese Candlestick Chart)

Example

Description of the TYPE of graph

A candlestick chart is a type of chart used to represent the start and end value of a variable over a given time period. It is often used in finance to represent the price movements of some commodity such as a stock, bond, or currency.

Description of the DATA

I found the data that I used in this chart at the Wall Street Journal’s website (here). It covers the opening and closing values of the Dow Jones Industrial Average since the start of 2023. The open, high, low, and close variables are all continuous measures of the DJIA’s price. The date is a discrete ordinal variable.

Representation Description:

The Candlestick chart is meant to show trends in the value of a variable over time, with aesthetic choices that assist forecasting. A chart consists of a series of vertical bars or “candles.” Each time period (e.g. a day, a week, an hour) in the data is represented by a single candle. Each candlestick shows the starting and ending value for that time period (for example, the opening and closing price of a stock for that day). The ends of the box/body of the candlestick represent the starting and ending values. When the starting value is higher than the ending value, the candlestick is usually filled black or red to indicate a decreasing trend. When the ending value is higher than the starting value, the candlestick is typically colored white or green (positive trend).

Each candlestick has upper and lower “shadows” (lines sticking out of it) that are also called wicks or tails. The wicks/tails represent the highest and lowest values of the time period. For example, the price of a stock may drop and rise throughout the course of trading, and so it may be worth more than its lowest price that day at the end of trading. The length of the wicks or tails helps provide information about the volatility of the measured variable during that period.

Figure source: https://datavizcatalogue.com/methods/candlestick_chart.html

How to read it & what to look for:

One of the strengths of Candlestick Charts is detecting and predicting trends over time. Different combinations of candle shapes lend themselves to different interpretations. A newer candlestick chart reader should break down the graph into a few key components:

Look at the color of the body of the candlesticks to see how the value of the variable changed in the 1-unit time period. Did it go up or down?
How big is the body of the candlestick relative to those on either side of it? A longer body indicates a stronger trend while a shorter body indicates a weaker one.
Examine the tails or wicks of each candle stick. Longer wicks suggest the variable’s value is more volatile, and vice versa.
Look at different “runs” of candlesticks to see if there is a continuous trend. For example, if there are several red or black candlesticks in a row with short wicks and bodies, then the value of the variable is trending downwards at a steady pace without much volatility.

Certain applications of candlestick plots will capture other latent meanings. During stock trading, for instance, the length of the wicks may be telling about the market’s psychology or beliefs. A steadily increasing run of green candle bodies but with long wicks and tails may suggest optimism or enthusiasm for an asset, but simultaneously a lack of confidence.

Presentation tips

By convention, candlestick bars are colored green or white (no fill) to indicate an increase in value per unit time while bars are colored red or black to indicate a decrease in value. While the convention for which exact color is used may be changed for aesthetics, inclusion of color is necessary for interpretation. The fill of the candlesticks always encodes its own channel of information.

Other annotations may be used to highlight a particular trend in a given time period, such as whether the value of the variable is going up or down. (This could be stock prices, number of COVID-19 tests ordered by healthcare professionals, amount of blood lactate in an athlete before and after practice, etc.).

Finally, marking the median value of the variable for a 1-unit time period on the candlesticks may help include a little bit more information about the velocity of the volatility within a given time period (i.e. was the increase or decrease sudden?).

Variations and alternatives

Some of the alternatives or variations on this graph are the open-high-low chart](https://datavizcatalogue.com/methods/OHLC_chart.html) (OHLC) and the Kagi chart](https://datavizcatalogue.com/methods/kagi_chart.html). OHLC charts and candlestick charts show the same information, but use right and left tick marks on the high-low volatility line to indicate starting and ending value.

Kagi charts vary in color and line width as they trace the value of an asset/variable over time. They are primarily used to track supply and demand over time for a market good rather than capture the broadstrokes sentiment of the market itself (like a candlestick chart of OHLC).

How to create it/Methods section

Below is the code that I used to load the data and generate the candlestick chart (using R, tidyverse, and ggplot2). I decided to use two geom_segments, one for the high-low volatility line and the other for the opening and closing marks. I layered the high-low volatility line behind the opening and closing marks to better create the tail or wick effect (as if the colored rectangle were the body of a candle).

# data downloaded from https://www.wsj.com/market-data/quotes/index/DJIA/historical-prices
# then loaded locally. fortunately the data was already in tidy format and did not require any wrangling

fin_data <- read_csv("data/HistoricalPrices.csv") %>%
  mutate(Date = mdy(Date)) # use the lubridate library to convert the date column 
glimpse(fin_data)

candlestick <- fin_data %>%
  # add a variable to record if the djia increased or decreased on the day
  mutate(green_red = if_else(Open < Close, "red", "green")) %>%
  ggplot() +
  aes(x = Date) +
  # want to plot the high-low volatility line behind the body of the candle
  geom_segment(
    aes(
      xend = Date
      , y = High
      , yend = Low
    )
    , linewidth = 0.5
    , color = "black"
  ) +
  # body of the candle goes here
  geom_segment(
    aes(
      xend = Date
      , y = Open
      , yend = Close
      , color = green_red
    )
    , linewidth = 2 # make the candle body wider than the tails/wicks!
  ) +
  labs(
    x = "Date"
    , y = "Price ($)"
    , title = "Opening and Closing Prices of the DJIA for 2023"
  ) +
  # colored this way by convention, but would be better to use a colorblind-friendly scheme
  # could use white and black?
  scale_color_manual(values = c("red", "green")) + 
  # use the scales::comma function to add commas appropriately for dollar amounts
  scale_y_continuous(labels = comma) +
  theme_bw() +
  theme(
    axis.text.x.bottom = element_text(angle = 90)
    , legend.position = "none"
  )
# let's print!
candlestick

Citations

Candlestick Chart - Learn about This Chart and Tools to Create It. https://datavizcatalogue.com/methods/candlestick_chart.html. Accessed 30 Apr. 2023.
DJIA | Dow Jones Industrial Average Historical Prices - WSJ. https://www.wsj.com/market-data/quotes/index/DJIA/historical-prices. Accessed 30 Apr. 2023.
Open-High-Low-Close Chart (OHLC Chart) - Learn about Here. https://datavizcatalogue.com/methods/OHLC_chart.html. Accessed 30 Apr. 2023.
Kagi Chart - Learn about This Chart and Tools to Create It. https://datavizcatalogue.com/methods/kagi_chart.html. Accessed 30 Apr. 2023.