如何在R的tidyverse中启用多核CPU加速ggplot绘图？——基于Intel Core i9设备的性能优化问询

Great question! Let’s break this down clearly since you’re running an Intel Core i9—you’ve got plenty of cores to leverage for speeding up your ggplot2 workflow. First, a key clarification:

ggplot2 is almost entirely CPU-bound, not GPU-dependent. Its core tasks (data processing, calculating geometric shapes, rendering layers) all happen on the CPU. GPUs only come into play for niche use cases like interactive 3D plots, so your i9’s multicore power is absolutely relevant here.

Below are actionable, practical ways to use those cores to speed up your specific workflow:

1. Start with the biggest bottleneck: Reading large datasets #

Your code uses read.csv() which is single-threaded and slow for big files. Swap it out for data.table::fread(), which automatically uses multiple cores to read CSV files—this alone can cut your data-loading time by 50% or more:

library(data.table)
df <- fread("path/TMean.csv") # Multi-core by default

2. Parallelize data prep and model calculations #

While ggplot2’s core rendering is single-threaded, the steps before plotting (like model fitting or data transformation) can be parallelized easily with the furrr package (built on future):

• First, set up a parallel session matching your i9’s core count (stick to 6-8 workers to avoid overloading):

  library(furrr)
  plan(multisession, workers = 8) # Adjust based on your total cores
  

• For your linear model: Even for a single model, pairing parallel setup with fast data reading will shave off time. If you ever need to fit multiple models (e.g., grouped by region), this approach scales seamlessly. Here’s how it fits into your code:

  # Parallel model fitting (scales if you add more groups later)
  model_df <- future_map(list(df), ~lm(tmean ~ year, data = .x))[[1]]
  
  # Calculate R² and formula as before
  model_formula <- get_formula(model_df)
  r_squared_df <- round(summary(model_df)$r.squared, digits = 4)
  

3. Optimize the ggplot rendering itself #

While ggplot’s rendering is single-threaded, you can reduce the CPU load by simplifying what it has to render:

• For large scatter plots like yours, consider downsampling points if you don’t need every single data point visible. You can do this in parallel too:

  # Parallel downsampling: Keep 10% of points per year
  sampled_df <- future_map_dfr(unique(df$year), function(y) {
    subset_df <- df[df$year == y, ]
    subset_df[sample(nrow(subset_df), size = nrow(subset_df)*0.1), ]
  })
  # Use sampled_df for plotting instead of the full dataset
  

• Use ggsave() with Cairo rendering to speed up saving the final plot—it’s faster for dense plots with lots of points:

  ggsave("temp_change_plot.png", final_plot, type = "cairo", dpi = 300)
  

Full optimized code for your workflow #

Here’s how all these tweaks come together in your original code:

library(data.table)
library(furrr)
library(ggplot2)
library(scales)

# Set up multi-core session
plan(multisession, workers = 8)

# Fast multi-core data reading
df <- fread("path/TMean.csv")

# Parallel model fitting
model_df <- future_map(list(df), ~lm(tmean ~ year, data = .x))[[1]]
model_formula <- get_formula(model_df)
r_squared_df <- round(summary(model_df)$r.squared, digits = 4)

# Build the plot (using full data or sampled data)
gg <- df %>% 
  ggplot(aes(x = year, y = tmean)) + 
  geom_point(aes(color = "Temperature"), size = 2, shape = 1, alpha = 0.1) + 
  geom_smooth(method = lm, aes(linetype = "LM"), se = FALSE, color = "red") + 
  scale_linetype_manual(values = 2, name = NULL) + 
  scale_colour_manual(values = "deepskyblue4", name = "Legend") + 
  theme(text = element_text(size = 16)) + 
  xlab("Year") + 
  ylab("Mean Temperature (℃)") + 
  ggtitle("1980-2021 Historical Change")+ 
  guides(color = guide_legend(override.aes = list(alpha = 0.5), order = 1))

# Add formula and R² text
final_plot <- gg + 
  geom_text(x = 1983.2, y = 30.8, label = paste0("Formula = ", model_formula), color = 'red') + 
  geom_text(x = 1980, y = 30.4, label = paste0("R² = ", r_squared_df), color = 'blue')

# Save with fast Cairo rendering
ggsave("1980-2021_temp_change.png", final_plot, type = "cairo", dpi = 300)

Quick recap #

Your Intel Core i9 is perfect for speeding up this workflow—focus on multi-core data reading and parallelizing pre-plot tasks (like model fitting or downsampling) since those are the easiest wins. ggplot’s rendering itself doesn’t use multiple cores, but reducing the amount of data it has to process will make that step faster too.

内容的提问来源于stack exchange，提问作者Ed_Gravy