如何高效处理/丰富R语言中矩阵/数据框的每个元素？

问题背景 #

需要合并values、scores和metadata三个数据源，为矩阵每个元素生成包含多维度信息的文本。当前采用嵌套for循环实现，但面对300×2500这类大矩阵时效率不足，希望找到更优方案，同时明确提前子集化metadata的合理性，以及循环内匹配操作的资源消耗情况。

初始化代码：

# init
library(glue)
set.seed(2304195)
metadata <- data.frame(p.status = sample(c('High', 'Low'), 200, TRUE),
                       type = sample(c('A', 'B', 'C', 'D'), 200, TRUE))
rownames(metadata) <- paste0('sample-', 1:200)

values <- matrix(runif(100, 0, 5))
for(i in 1:99) {
  values <- cbind(values, runif(100, 0, 50))
}
colnames(values) <- paste0('sample-', sample(1:200, 100))
rownames(values) <- paste0('gene-', 1:100)

scores <- t(scale(t(log2(values + 1))))

当前低效的嵌套循环实现：

# 'enriching' data
for(j in seq_along(rownames(values))) {
  for(k in seq_along(colnames(values))) {
    values[j, k] <- glue('ID: <b>{colnames(values)[k]}</b>\n',
                         'p. status: <b>{metadata$p.status[which(rownames(metadata) == colnames(values)[k])]}</b>\n',
                         'type: <b>{metadata$type[which(rownames(metadata) == colnames(values)[k])]}</b>\n',
                         'symbol: <b>{rownames(values)[j]}</b>\n',
                         'log<sub>2</sub> expression: <b>{round(as.numeric(values[j, k]), 2)}</b>\n',
                         'z-score: <b>{round(scores[j, k], 2)}</b>')
  }
}

高效优化方案 #

1. 提前子集化metadata，消除循环内重复查找 #

循环内的which(rownames(metadata) == colnames(values)[k])是极大的效率瓶颈：每次循环都要遍历metadata所有行做匹配，对于大矩阵来说重复次数达nrow(values)*ncol(values)次，CPU资源消耗极高。

正确做法是先提取metadata中与values列名匹配的子集，同时保留样本ID列：

# 提前筛选metadata中需要的样本，同时保留样本ID列
metadata_subset <- metadata[colnames(values), , drop = FALSE]
metadata_subset$sample_id <- rownames(metadata_subset)

2. 向量化操作替代嵌套循环（推荐） #

将矩阵转换为长格式数据框，利用dplyr的向量化合并和glue的批量生成能力，彻底避免逐元素循环：

首先加载必要工具包：

library(dplyr)
library(tidyr)

执行步骤如下：

# 1. 将values和scores矩阵转为长格式数据框
values_long <- as.data.frame(values) %>%
  rownames_to_column("gene_symbol") %>%
  pivot_longer(cols = -gene_symbol, names_to = "sample_id", values_to = "log2_expr")

scores_long <- as.data.frame(scores) %>%
  rownames_to_column("gene_symbol") %>%
  pivot_longer(cols = -gene_symbol, names_to = "sample_id", values_to = "z_score")

# 2. 合并所有数据源
combined_data <- values_long %>%
  inner_join(scores_long, by = c("gene_symbol", "sample_id")) %>%
  inner_join(metadata_subset, by = "sample_id")

# 3. 批量生成富文本内容
combined_data$rich_text <- glue('ID: <b>{sample_id}</b>\n',
                                'p. status: <b>{p.status}</b>\n',
                                'type: <b>{type}</b>\n',
                                'symbol: <b>{gene_symbol}</b>\n',
                                'log<sub>2</sub> expression: <b>{round(log2_expr, 2)}</b>\n',
                                'z-score: <b>{round(z_score, 2)}</b>')

# 4. 将长格式转回矩阵格式（如需保留原矩阵结构）
result_matrix <- combined_data %>%
  select(gene_symbol, sample_id, rich_text) %>%
  pivot_wider(names_from = sample_id, values_from = rich_text) %>%
  column_to_rownames("gene_symbol") %>%
  as.matrix()

这种向量化方式依托R底层优化，避免了R层面的循环开销，效率远高于嵌套循环，处理300×2500的矩阵也能快速完成。

3. 并行计算的适用场景 #

仅当数据量极大（如1000×10000以上）时，才考虑用foreach结合%dopar%实现并行。需注意：并行存在启动和通信开销，小数据量下反而可能更慢；实现时建议按行或按列拆分任务，避免逐元素并行（开销过大）。

示例代码（按行并行）：

library(foreach)
library(doParallel)

# 注册并行集群
cl <- makeCluster(detectCores() - 1)
registerDoParallel(cl)

# 按行处理
result_list <- foreach(j = seq_len(nrow(values)), .packages = c("glue")) %dopar% {
  gene_symbol <- rownames(values)[j]
  current_values <- values[j, ]
  current_scores <- scores[j, ]
  
  # 逐列生成文本（单循环，减少一层嵌套开销）
  sapply(seq_len(ncol(values)), function(k) {
    sample_id <- colnames(values)[k]
    meta <- metadata_subset[sample_id, ]
    glue('ID: <b>{sample_id}</b>\n',
         'p. status: <b>{meta$p.status}</b>\n',
         'type: <b>{meta$type}</b>\n',
         'symbol: <b>{gene_symbol}</b>\n',
         'log<sub>2</sub> expression: <b>{round(current_values[k], 2)}</b>\n',
         'z-score: <b>{round(current_scores[k], 2)}</b>')
  })
}

# 合并为矩阵
result_matrix_parallel <- do.call(rbind, result_list)
rownames(result_matrix_parallel) <- rownames(values)
colnames(result_matrix_parallel) <- colnames(values)

# 关闭集群
stopCluster(cl)

关键结论 #

• 提前子集化metadata非常必要：循环内的重复匹配会占用大量CPU资源，提前筛选能将这部分开销从O(N*M)降至O(M)（M为样本数）
• 优先使用向量化操作：这是R中提升效率的核心手段，性能远优于嵌套循环
• 并行计算仅在数据量极大时考虑：小数据量下向量化已足够高效，并行的开销可能抵消收益

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