OSCR

Benchmarking privacy and utility in synthetic tabular cohorts for Alzheimer's disease research.

Code ↔ Paper

7 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 7 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § METHODS › Privacy evaluation ↔ R/benchmark.plots.R, lines 273–317 · score 0.67 · privacy loss, hitting rate, identifiability risk, ADR, NNDR, NNAA
  2. [2] § RESULTS › Privacy analysis ↔ R/bmk_ctgan.R, the whole file · a weak match · score 0.60 · confidence interval, hitting rate, identifiability risk, recall, MIA, CTGAN
  3. [3] § RESULTS › Privacy analysis ↔ R/bmk_degrees.R, lines 1–72 · score 0.59 · confidence interval, hitting rate, identifiability risk, recall, MIA, score
  4. [4] § METHODS › Generating synthetic tabular data ↔ python/bayesian_synthesizing.py, lines 17–59 · score 0.56 · correlated attribute mode, Bayesian networks, root, privacy
  5. [5] § METHODS › Utility evaluation › Missing values ↔ python/train_svm.py, lines 108–116 · score 0.56 · IterativeImputer, SimpleImputer, imputed, training
  6. [6] § METHODS › Utility evaluation › Missing values ↔ python/main_ctgan.py, lines 31–43 · score 0.56 · IterativeImputer, SimpleImputer, imputed, CTGAN
  7. [7] § METHODS › Privacy evaluation ↔ python/eval_benchmark.py, lines 111–140 · score 0.53 · SynthEval, hitting rate, NNDR, benchmarking, NNAA, MIA

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

R · 717 lines · 28 KB · MIT · 1 match

  1. library(dplyr)
  2. library(Rmisc)
  3. library(ggplot2)
  4. library(ggpubr)
  5. library(stringr)
  6. library(ggforce)
  7. library(paletteer)
  8. library(ggsci)
  10. ##### ADNI #####
  11. epsilons <- c(5, 10, 50, 100, 200, NA)
  12. samples <- c(rep(100, length(epsilons)-length(which(is.na(epsilons)))), 18)
  13. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/adni/bmk_new_deg2_eps", ifelse(is.na(epsilons), "zero", epsilons), ".csv")
  15. # Read CSVs in a loop
  16. res_list <- list()
  17. for (i in seq_along(epsilons)) {
  18. df <- read.csv(file_paths[i])
  19. df$Epsilon <- epsilons[i]
  20. df$samples <- samples[i]
  21. res_list[[i]] <- df
  22. }
  24. # Combine all data frames
  25. bmk_ds <- bind_rows(res_list)
  28. util_cols <- c("mutual_inf_diff_value", "ks_tvd_stat_value",
  29. "frac_ks_sigs_value","avg_F1_diff_value", "avg_F1_diff_hout_value",
  30. "nnaa_value")
  31. priv_cols <- c("priv_loss_nndr_value", "priv_loss_nnaa_value","hit_rate_value",
  32. "avg_nndr_value", "eps_identif_risk_value", "priv_loss_eps_value",
  33. "mia_recall_value", "att_discl_risk_value")
  34. cols <- c(util_cols, priv_cols)
  37. bmk_ds$Epsilon <- bmk_ds %>%
  38. select(Epsilon) %>%
  39. mutate_all(~replace(., is.na(.), 0)) %>%
  40. mutate(Epsilon = factor(Epsilon, levels = as.character(unique(Epsilon)))) %>%
  41. pull(Epsilon)
  43. # CTGAN
  44. epochs <- c(750)
  45. setting <- c("default", "optim")
  46. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/adni/bmk_new_ctgan_", setting, "_epochs_", epochs, ".csv")
  47. #file_paths <- c(file_paths, "~/Python/WASP-DDLS/SE-benchmark/bmk_ctgan_epochs_100.csv")
  49. # Read CSVs in a loop
  50. res_list <- list()
  51. for (i in seq_along(file_paths)) {
  52. df <- read.csv(file_paths[i])
  53. df$Epochs <- epochs[i]
  54. df$samples <- 100
  55. res_list[[i]] <- df
  56. }
  58. # Combine all data frames
  59. bmk_ctgan <- bind_rows(res_list)
  61. bmk_ctgan$Epochs <- as.factor(bmk_ctgan$Epochs)
  64. # Synthpop
  65. bmk_synthpop <- read.csv("~/Python/WASP-DDLS/SE-benchmark/adni/bmk_synthpop_2.csv") %>% mutate(
  66. Epochs = 0,
  67. samples = 100
  68. )
  70. # TabPFN
  71. temps <- c('1.0', '0.75', '0.5', '0.25')
  72. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/adni/bmk_new_tabpfn_t_", temps, ".csv")
  74. # Read CSVs in a loop
  75. res_list <- list()
  76. for (i in seq_along(file_paths)) {
  77. df <- read.csv(file_paths[i])
  78. df$temp <- temps[i]
  79. df$samples <- 100
  80. res_list[[i]] <- df
  81. }
  83. # Combine all data frames
  84. bmk_tabpfn <- bind_rows(res_list)
  86. bmk_tabpfn$temp <- as.factor(bmk_tabpfn$temp)
  89. label_list = c("DS (5)", "DS (10)","DS (50)","DS (100)",
  90. "DS (200)", "DS w/o DP", "CTGAN (default)", "CTGAN (optimal)",
  91. "Synthpop",
  92. "TabPFN (t=1.0)", "TabPFN (t=0.75)", "TabPFN (t=0.5)", "TabPFN (t=0.25)")
  94. util_df_adni <- rbind(select(bmk_ds, dataset, model, all_of(util_cols)),
  95. select(bmk_ctgan, dataset, model, all_of(util_cols)),
  96. select(bmk_synthpop, dataset, model, all_of(util_cols)),
  97. select(bmk_tabpfn, dataset, model, all_of(util_cols))) |>
  98. dplyr::mutate(avg_F1_diff_value = abs(avg_F1_diff_value),
  99. avg_F1_diff_hout_value = abs(avg_F1_diff_hout_value)) |>
  100. dplyr::mutate(mutual_inf_diff = 1 - tanh(mutual_inf_diff_value),
  101. ks_tvd_stat = 1 - ks_tvd_stat_value,
  102. frac_ks_sigs = 1 - frac_ks_sigs_value,
  103. avg_F1_diff = 1 - abs(avg_F1_diff_value),
  104. avg_F1_diff_hout = 1 - abs(avg_F1_diff_hout_value),
  105. nnaa = 1 - nnaa_value)
  106. util_df_adni$util_score <- util_df_adni |> dplyr::select(c(mutual_inf_diff, ks_tvd_stat, frac_ks_sigs, avg_F1_diff, avg_F1_diff_hout, nnaa)) |> rowMeans()
  108. util_df_adni$Method <- factor(util_df_adni$dataset, levels = unique(util_df_adni$dataset),
  109. labels=label_list)
  111. priv_df_adni <- rbind(select(bmk_ds, dataset, model, all_of(priv_cols)),
  112. select(bmk_ctgan, dataset, model, all_of(priv_cols)),
  113. select(bmk_synthpop, dataset, model, all_of(priv_cols)),
  114. select(bmk_tabpfn, dataset, model, all_of(priv_cols))) |>
  115. dplyr::mutate(priv_loss_nndr = 1 - abs(priv_loss_nndr_value),
  116. priv_loss_nnaa = 1 - abs(priv_loss_nnaa_value),
  117. priv_loss_eps = 1 - abs(priv_loss_eps_value),
  118. hit_rate = 1 - hit_rate_value,
  119. eps_identif_risk = 1 - eps_identif_risk_value,
  120. mia_recall = 1 - mia_recall_value,
  121. att_discl_risk = 1 - att_discl_risk_value)
  122. priv_df_adni$priv_score <- priv_df_adni |> dplyr::select(c(priv_loss_nndr, priv_loss_nnaa, priv_loss_eps, hit_rate, eps_identif_risk, att_discl_risk)) |> rowMeans()
  124. priv_df_adni$Method <- factor(priv_df_adni$dataset, levels = unique(priv_df_adni$dataset),
  125. labels=label_list)
  127. up_df_adni <- util_df_adni |> dplyr::select(c(Method, model, util_score)) |>
  128. dplyr::inner_join(priv_df_adni |> dplyr::select(c(Method, model, priv_score)), by = c("Method", "model"))
  131. colormap <- c(
  132. paletteer_d("rcartocolor::BluYl")[1:6],
  133. paletteer_d("beyonce::X58")[3:4],
  134. "#663399",
  135. paletteer_d("ggsci::cyan_material")[c(1,3,5,7)]
  136. )
  138. up_plot_adni <- ggplot(data = up_df_adni, aes(x=util_score, y=priv_score, fill=Method)) +
  139. geom_point(pch=21, color = "black", size=3) +
  140. labs(title = "ADNI", x = "Utility", y = "Privacy") +
  141. #scale_fill_paletteer_d("rcartocolor::BluYl") +
  142. scale_fill_manual(values = colormap) +
  143. theme_minimal() +
  144. ylim(0.7,1.0) + xlim(0.3,0.85)
  146. plot(up_plot_adni)
  148. #ggsave("~/R/DDLS-plots/up_plot.png", up_plot, width = 7, height = 5, units = "in", dpi = 500)
  150. ###### A4 #########
  151. epsilons <- c(5, 10, 50, 100, 200, NA)
  152. samples <- c(rep(100, length(epsilons)-length(which(is.na(epsilons)))), 23)
  153. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/a4/bmk_new_deg2_eps", ifelse(is.na(epsilons), "zero", epsilons), ".csv")
  155. # Read CSVs in a loop
  156. res_list <- list()
  157. for (i in seq_along(epsilons)) {
  158. df <- read.csv(file_paths[i])
  159. df$Epsilon <- epsilons[i]
  160. df$samples <- samples[i]
  161. res_list[[i]] <- df
  162. }
  164. # Combine all data frames
  165. bmk_ds <- bind_rows(res_list)
  168. util_cols <- c("mutual_inf_diff_value", "ks_tvd_stat_value",
  169. "frac_ks_sigs_value","avg_F1_diff_value", "avg_F1_diff_hout_value",
  170. "nnaa_value")
  171. priv_cols <- c("priv_loss_nndr_value", "priv_loss_nnaa_value","hit_rate_value",
  172. "avg_nndr_value", "eps_identif_risk_value", "priv_loss_eps_value",
  173. "mia_recall_value", "att_discl_risk_value")
  174. cols <- c(util_cols, priv_cols)
  177. bmk_ds$Epsilon <- bmk_ds %>%
  178. select(Epsilon) %>%
  179. mutate_all(~replace(., is.na(.), 0)) %>%
  180. mutate(Epsilon = factor(Epsilon, levels = as.character(unique(Epsilon)))) %>%
  181. pull(Epsilon)
  183. # CTGAN
  184. epochs <- c(750)
  185. setting <- c("default", "optim")
  186. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/a4/bmk_new_ctgan_", setting, "_epochs_", epochs, ".csv")
  187. #file_paths <- c(file_paths, "~/Python/WASP-DDLS/SE-benchmark/bmk_ctgan_epochs_100.csv")
  189. # Read CSVs in a loop
  190. res_list <- list()
  191. for (i in seq_along(file_paths)) {
  192. df <- read.csv(file_paths[i])
  193. df$Epochs <- epochs[i]
  194. df$samples <- 100
  195. res_list[[i]] <- df
  196. }
  198. # Combine all data frames
  199. bmk_ctgan <- bind_rows(res_list)
  201. bmk_ctgan$Epochs <- as.factor(bmk_ctgan$Epochs)
  204. # Synthpop
  205. bmk_synthpop <- read.csv("~/Python/WASP-DDLS/SE-benchmark/a4/bmk_new_synthpop.csv") %>% mutate(
  206. Epochs = 0,
  207. samples = 100
  208. )
  210. # TabPFN
  211. temps <- c('1.0')
  212. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/a4/bmk_new_tabpfn_t_", temps, ".csv")
  214. # Read CSVs in a loop
  215. res_list <- list()
  216. for (i in seq_along(file_paths)) {
  217. df <- read.csv(file_paths[i])
  218. df$temp <- temps[i]
  219. df$samples <- 100
  220. res_list[[i]] <- df
  221. }
  223. # Combine all data frames
  224. bmk_tabpfn <- bind_rows(res_list)
  226. bmk_tabpfn$temp <- as.factor(bmk_tabpfn$temp)
  229. label_list = c("DS (5)", "DS (10)", "DS (50)", "DS (100)", "DS (200)", "DS w/o DP",
  230. "CTGAN (default)", "CTGAN (optimal)",
  231. "Synthpop", "TabPFN (t=1.0")
  233. util_df_a4 <- rbind(select(bmk_ds, dataset, model, all_of(util_cols)),
  234. select(bmk_ctgan, dataset, model, all_of(util_cols)),
  235. select(bmk_synthpop, dataset, model, all_of(util_cols)),
  236. select(bmk_tabpfn, dataset, model, all_of(util_cols))
  237. ) |>
  238. dplyr::mutate(avg_F1_diff_value = abs(avg_F1_diff_value),
  239. avg_F1_diff_hout_value = abs(avg_F1_diff_hout_value)) |>
  240. dplyr::mutate(mutual_inf_diff = 1 - tanh(mutual_inf_diff_value),
  241. ks_tvd_stat = 1 - ks_tvd_stat_value,
  242. frac_ks_sigs = 1 - frac_ks_sigs_value,
  243. avg_F1_diff = 1 - abs(avg_F1_diff_value),
  244. avg_F1_diff_hout = 1 - abs(avg_F1_diff_hout_value),
  245. nnaa = 1 - nnaa_value)
  246. util_df_a4$util_score <- util_df_a4 |> dplyr::select(c(mutual_inf_diff, ks_tvd_stat, frac_ks_sigs, avg_F1_diff, avg_F1_diff_hout, nnaa)) |> rowMeans()
  248. util_df_a4$Method <- factor(util_df_a4$dataset, levels = unique(util_df_a4$dataset),
  249. labels=label_list)
  251. priv_df_a4 <- rbind(select(bmk_ds, dataset, model, all_of(priv_cols)),
  252. select(bmk_ctgan, dataset, model, all_of(priv_cols)),
  253. select(bmk_synthpop, dataset, model, all_of(priv_cols)),
  254. select(bmk_tabpfn, dataset, model, all_of(priv_cols))
  255. ) |>
  256. dplyr::mutate(priv_loss_nndr = 1 - abs(priv_loss_nndr_value),
  257. priv_loss_nnaa = 1 - abs(priv_loss_nnaa_value),
  258. priv_loss_eps = 1 - abs(priv_loss_eps_value),
  259. hit_rate = 1 - hit_rate_value,
  260. eps_identif_risk = 1 - eps_identif_risk_value,
  261. mia_recall = 1 - mia_recall_value,
  262. att_discl_risk = 1 - att_discl_risk_value)
  263. priv_df_a4$priv_score <- priv_df_a4 |> dplyr::select(c(priv_loss_nndr, priv_loss_nnaa, priv_loss_eps, hit_rate, eps_identif_risk, att_discl_risk)) |> rowMeans()
  265. priv_df_a4$Method <- factor(priv_df_a4$dataset, levels = unique(priv_df_a4$dataset),
  266. labels=label_list)
  268. up_df_a4 <- util_df_a4 |> dplyr::select(c(Method, model, util_score)) |>
  269. dplyr::inner_join(priv_df_a4 |> dplyr::select(c(Method, model, priv_score)), by = c("Method", "model"))
  271. up_df_a4 <- up_df_a4 %>% mutate(Framework = as.factor(gsub(" .*", "", Method)))
  273. #up_df$Method <- factor(up_df$dataset, levels = unique(up_df$dataset),
  274. # labels=c("DS (eps=5)", "DS (eps=10)", "DS (eps=25)","DS (eps=50)","DS (eps=100)",
  275. # "DS (eps=200)", "DS w/o DP", "CTGAN (10 epochs)",
  276. # "CTGAN (50 epochs)", "CTGAN (100 epochs)", "Synthpop"))
  278. colormap <- c(
  279. paletteer_d("rcartocolor::BluYl")[1:6],
  280. paletteer_d("beyonce::X58")[3:4],
  281. "#663399",
  282. paletteer_d("ggsci::cyan_material")[c(1,3,5,7)]
  283. )
  285. up_plot_a4 <- ggplot(data = up_df_a4, aes(x=util_score, y=priv_score, fill=Method)) +
  286. geom_point(pch=21, color="black", size=3) +
  287. labs(title = "A4", x = "Utility", y = "Privacy") +
  288. #scale_fill_paletteer_d("rcartocolor::BluYl") +
  289. scale_fill_manual(values = colormap) +
  290. theme_minimal() +
  291. ylim(0.7,1.0) + xlim(0.3,0.85)
  293. #plot(up_plot_a4)
  295. up_plot <- ggarrange(up_plot_adni, up_plot_a4, nrow=2, common.legend = TRUE, legend = "right")
  296. plot(up_plot)
  298. #ggsave("~/R/DDLS-plots/up_plot.jpg", up_plot, width = 7, height = 10, units = "in", dpi = 1000)
  300. ###### GRIDS OF METRICS ######
  301. library(lme4)
  303. # Privacy grid
  305. privs <- c("priv_loss_nndr_value", "priv_loss_nnaa_value", "eps_identif_risk_value", "hit_rate_value", "mia_recall_value", "att_discl_risk_value")
  306. priv_titels <- c(
  307. priv_loss_nndr_value = "NNDR privacy loss",
  308. priv_loss_nnaa_value = "NNAA privacy loss",
  309. eps_identif_risk_value = "Epsilon identifiability",
  310. hit_rate_value = "Hitting rate",
  311. mia_recall_value = "MIA",
  312. att_discl_risk_value = "ADR"
  313. )
  314. priv_df_adni <- priv_df_adni %>% mutate(eps_identif_risk_value = eps_identif_risk_value*100,
  315. hit_rate_value = hit_rate_value*100)
  316. priv_df_a4 <- priv_df_a4 %>% mutate(eps_identif_risk_value = eps_identif_risk_value*100,
  317. hit_rate_value = hit_rate_value*100)
  319. get_privacy_plot <- function(priv_df, p) {
  320. pp <- ggplot(data = priv_df, aes(x = Method, y = !!sym(p), fill = Method)) +
  321. labs(title = priv_titels[p],
  322. x = "",
  323. y = "") +
  324. scale_fill_manual(values = colormap) +
  325. theme_classic() +
  326. theme(axis.text.x = element_text(angle = 30, vjust = 1, hjust=1, size = 8))
  327. if(p %in% c("eps_identif_risk_value", "hit_rate_value")) {
  328. yval = 9.0
  329. pp <- pp + geom_hline(yintercept = yval, linetype = "dashed", color = "darkred") +
  330. geom_rect(
  331. xmin = -Inf, xmax = Inf,
  332. ymin = yval, ymax = Inf,
  333. fill = "grey80",
  334. alpha = 0.5
  335. )
  336. } else if(p %in% c("priv_loss_nndr_value", "priv_loss_nnaa_value")) {
  337. mu = mean(priv_df[[p]], na.rm=T)
  338. #m = length(unique(priv_df$Method))
  339. #n = nrow(priv_df)/m
  340. #se = sd(priv_df[[p]], na.rm=T)/sqrt(n)
  341. #t_crit <- qt(1 - 0.01 / (2 * m), df = round(n)-1)
  343. form <- as.formula(paste(p, "~ 1 + (1 | Method)"))
  344. fit <- lmer(form, data = priv_df)
  345. cis <- confint(fit, level = 0.99, parm = "(Intercept)")
  347. upper = cis[2]
  348. lower = cis[1]
  350. pp <- pp +
  351. geom_hline(yintercept = mu, linetype = "solid", color = "lightgray") +
  352. geom_hline(yintercept = upper, linetype = "dashed", color = "darkred", alpha=0.5) +
  353. geom_hline(yintercept = lower, linetype = "dashed", color = "darkred", alpha=0.5) +
  354. geom_rect(xmin = -Inf, xmax = Inf, ymin = upper, ymax = Inf, fill = "grey80", alpha = 0.2) +
  355. geom_rect(xmin = -Inf, xmax = Inf, ymin = -Inf, ymax = lower, fill = "grey80", alpha = 0.2)
  356. } else if(p %in% c("mia_recall_value", "att_discl_risk_value")) {
  357. yval = 0.5
  358. pp <- pp + geom_hline(yintercept = yval, linetype = "dashed", color = "darkred") +
  359. geom_rect(
  360. xmin = -Inf, xmax = Inf,
  361. ymin = yval, ymax = Inf,
  362. fill = "grey80",
  363. alpha = 0.5
  364. )
  365. }
  366. pp <- pp + geom_hline(yintercept = 0.0, linetype = "dotted", color = "black") +
  367. geom_boxplot()
  369. return(pp)
  370. }
  373. pPlotlist_adni <- list()
  374. pPlotlist_a4 <- list()
  375. for (p in privs) {
  376. pp_adni <- get_privacy_plot(priv_df_adni, p)
  377. pp_a4 <- get_privacy_plot(priv_df_a4, p)
  378. pPlotlist_adni[[paste0(p, "_adni")]] <- pp_adni
  379. pPlotlist_a4[[paste0(p, "_a4")]] <- pp_a4
  380. }
  382. priv_grid_adni <- ggarrange(plotlist = pPlotlist_adni, ncol = 2, nrow = 3, common.legend = TRUE, legend = "right")
  383. plot(priv_grid_adni)
  385. priv_grid_a4 <- ggarrange(plotlist = pPlotlist_a4, ncol = 2, nrow = 3, common.legend = TRUE, legend = "right")
  386. plot(priv_grid_a4)
  388. ggsave("~/R/DDLS-plots/priv_grid_adni.tiff", priv_grid_adni, width = 10, height = 10, units = "in", dpi = 500)
  389. ggsave("~/R/DDLS-plots/priv_grid_a4.tiff", priv_grid_a4, width = 10, height = 10, units = "in", dpi = 500)
  391. #ggsave("~/R/DDLS-plots/util_grid.png", util_grid, width = 10, height = 10, units = "in", dpi = 500)
  392. #ggsave("~/R/DDLS-plots/priv_grid.png", priv_grid, width = 10, height = 10, units = "in", dpi = 500)
  394. utils <- c("mutual_inf_diff_value", "ks_tvd_stat_value", "frac_ks_sigs_value", "avg_F1_diff_value", "avg_F1_diff_hout_value", "nnaa_value")
  395. # Mapping column names
  396. util_titles <- c(
  397. mutual_inf_diff_value = "MI diff",
  398. ks_tvd_stat_value = "KS/TVD stat",
  399. frac_ks_sigs_value = "Frac. KS sigs",
  400. avg_F1_diff_value = "Avg. Diff. F1",
  401. avg_F1_diff_hout_value = "Avg. Diff. F1 (test)",
  402. nnaa_value = "NNAA value"
  403. )
  405. get_util_plot <- function(util_df, u) {
  406. up <- ggplot(data = util_df, aes(x = Method, y = !!sym(u), fill = Method)) +
  407. labs(title = util_titles[u],
  408. x = "",
  409. y = "") +
  410. scale_fill_manual(values = colormap) +
  411. theme_classic() +
  412. theme(axis.text.x = element_text(angle = 30, vjust = 1, hjust=1, size = 8))
  413. if (u == 'nnaa_value') {
  414. mu = mean(util_df[[u]], na.rm=T)
  415. #m = length(unique(priv_df$Method))
  416. #n = nrow(priv_df)/m
  417. #se = sd(priv_df[[p]], na.rm=T)/sqrt(n)
  418. #t_crit <- qt(1 - 0.01 / (2 * m), df = round(n)-1)
  420. form <- as.formula(paste(u, "~ 1 + (1 | Method)"))
  421. fit <- lmer(form, data = util_df)
  422. cis <- confint(fit, level = 0.99, parm = "(Intercept)")
  424. upper = cis[2]
  425. lower = cis[1]
  427. up <- up +
  428. geom_hline(yintercept = mu, linetype = "solid", color = "lightgray") +
  429. geom_hline(yintercept = upper, linetype = "dashed", color = "darkred", alpha=0.5) +
  430. geom_hline(yintercept = lower, linetype = "dashed", color = "darkred", alpha=0.5) +
  431. geom_rect(xmin = -Inf, xmax = Inf, ymin = upper, ymax = Inf, fill = "grey80", alpha = 0.2) +
  432. geom_rect(xmin = -Inf, xmax = Inf, ymin = -Inf, ymax = lower, fill = "grey80", alpha = 0.2)
  433. } else if (u == "frac_ks_sigs_value"){
  434. up <- up + geom_hline(yintercept = 1.0, linetype = "solid", color = "gray")
  435. }
  436. up <- up + geom_boxplot()
  437. return(up)
  438. }
  442. uPlotlist_adni <- list()
  443. uPlotlist_a4 <- list()
  444. for (u in utils) {
  445. uPlotlist_adni[[u]] <- get_util_plot(util_df_adni, u)
  446. uPlotlist_a4[[u]] <- get_util_plot(util_df_a4, u)
  447. }
  449. util_grid_adni <- ggarrange(plotlist = uPlotlist_adni, ncol = 2, nrow = 3, common.legend = TRUE, legend = "right")
  450. plot(util_grid_adni)
  452. util_grid_a4 <- ggarrange(plotlist = uPlotlist_a4, ncol = 2, nrow = 3, common.legend = TRUE, legend = "right")
  453. plot(util_grid_a4)
  455. ggsave("~/R/DDLS-plots/util_grid_adni.tiff", util_grid_adni, width = 10, height = 10, units = "in", dpi = 500)
  456. ggsave("~/R/DDLS-plots/util_grid_a4.tiff", util_grid_a4, width = 10, height = 10, units = "in", dpi = 500)
  458. ##### Get specific values #####
  460. summary_stats_adni <- up_df_adni %>%
  461. group_by(Method) %>%
  462. dplyr::summarize(
  463. mean_u = mean(util_score),
  464. mean_p = mean(priv_score),
  465. sd_u = sd(util_score),
  466. sd_p = sd(priv_score),
  467. num = n(),
  468. ci_margin_u = qt(0.975, df = n() - 1) * sd(util_score) / sqrt(n()),
  469. ci_margin_p = qt(0.975, df = n() - 1) * sd(priv_score) / sqrt(n()),
  470. ci_lwr_u = mean_u - ci_margin_u,
  471. ci_upr_u = mean_u + ci_margin_u,
  472. ci_lwr_p = mean_p - ci_margin_p,
  473. ci_upr_p = mean_p + ci_margin_p
  474. )
  476. summary_stats_a4 <- up_df_a4 %>%
  477. group_by(Method) %>%
  478. dplyr::summarize(
  479. mean_u = mean(util_score),
  480. mean_p = mean(priv_score),
  481. ci_margin_u = qt(0.975, df = n() - 1) * sd(util_score) / sqrt(n()),
  482. ci_margin_p = qt(0.975, df = n() - 1) * sd(priv_score) / sqrt(n()),
  483. ci_lwr_u = mean_u - ci_margin_u,
  484. ci_upr_u = mean_u + ci_margin_u,
  485. ci_lwr_p = mean_p - ci_margin_p,
  486. ci_upr_p = mean_p + ci_margin_p
  487. )
  489. priv_df_adni %>% group_by(dataset) %>%
  490. dplyr::summarise(Mean = mean(eps_identif_risk_value),
  491. SD = sd(eps_identif_risk_value),
  492. N = n(),
  493. margin = qt(0.975, df = n() - 1) * sd(eps_identif_risk_value) / sqrt(n()),
  494. lower = Mean - margin,
  495. upper = Mean + margin) %>% filter(upper > 0.09)
  497. priv_df_a4 %>% group_by(dataset) %>%
  498. dplyr::summarise(Mean = mean(eps_identif_risk_value),
  499. SD = sd(eps_identif_risk_value),
  500. N = n(),
  501. margin = qt(0.975, df = n() - 1) * sd(eps_identif_risk_value) / sqrt(n()),
  502. lower = Mean - margin,
  503. upper = Mean + margin) %>% filter(upper > 0.09)
  506. priv_df_adni %>% group_by(dataset) %>%
  507. dplyr::summarise(Mean = mean(att_discl_risk_value),
  508. SD = sd(att_discl_risk_value),
  509. N = n(),
  510. margin = qt(0.975, df = n() - 1) * sd(att_discl_risk_value) / sqrt(n()),
  511. lower = Mean - margin,
  512. upper = Mean + margin) %>% filter(upper > 0.1)
  515. priv_df_a4 %>% group_by(dataset) %>%
  516. dplyr::summarise(Mean = mean(att_discl_risk_value),
  517. SD = sd(att_discl_risk_value),
  518. N = n(),
  519. margin = qt(0.975, df = n() - 1) * sd(att_discl_risk_value) / sqrt(n()),
  520. lower = Mean - margin,
  521. upper = Mean + margin) %>% filter(upper > 0.1)
  523. priv_df_adni %>% group_by(dataset) %>%
  524. dplyr::summarise(Mean = mean(mia_recall_value),
  525. SD = sd(mia_recall_value),
  526. N = n(),
  527. margin = qt(0.975, df = n() - 1) * sd(mia_recall_value) / sqrt(n()),
  528. lower = Mean - margin,
  529. upper = Mean + margin) %>% filter(upper > 0.1)
  531. priv_df_a4 %>% group_by(dataset) %>%
  532. dplyr::summarise(Mean = mean(mia_recall_value),
  533. SD = sd(mia_recall_value),
  534. N = n(),
  535. margin = qt(0.975, df = n() - 1) * sd(mia_recall_value) / sqrt(n()),
  536. lower = Mean - margin,
  537. upper = Mean + margin) %>% filter(upper > 0.1)
  539. # Bonus experiment
  540. #### ADNI+ ####
  541. epsilons <- c(100, NA)
  542. samples <- c(100, 18)
  543. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/adni_plus/bmk_new_deg2_eps", ifelse(is.na(epsilons), "zero", epsilons), ".csv")
  545. # Read CSVs in a loop
  546. res_list <- list()
  547. for (i in seq_along(epsilons)) {
  548. df <- read.csv(file_paths[i])
  549. df$Epsilon <- epsilons[i]
  550. df$samples <- samples[i]
  551. res_list[[i]] <- df
  552. }
  554. # Combine all data frames
  555. bmk_ds <- bind_rows(res_list)
  558. util_cols <- c("mutual_inf_diff_value", "ks_tvd_stat_value",
  559. "frac_ks_sigs_value","avg_F1_diff_value", "avg_F1_diff_hout_value",
  560. "nnaa_value")
  561. priv_cols <- c("priv_loss_nndr_value", "priv_loss_nnaa_value","hit_rate_value",
  562. "avg_nndr_value", "eps_identif_risk_value", "priv_loss_eps_value",
  563. "mia_recall_value", "att_discl_risk_value")
  564. cols <- c(util_cols, priv_cols)
  567. bmk_ds$Epsilon <- bmk_ds %>%
  568. select(Epsilon) %>%
  569. mutate_all(~replace(., is.na(.), 0)) %>%
  570. mutate(Epsilon = factor(Epsilon, levels = as.character(unique(Epsilon)))) %>%
  571. pull(Epsilon)
  573. # CTGAN
  574. epochs <- c(750)
  575. setting <- c("default")
  576. file_paths <- paste0("~/Python/WASP-DDLS/SE-benchmark/adni_plus/bmk_new_ctgan_", setting, "_epochs_", epochs, ".csv")
  577. #file_paths <- c(file_paths, "~/Python/WASP-DDLS/SE-benchmark/bmk_ctgan_epochs_100.csv")
  579. # Read CSVs in a loop
  580. res_list <- list()
  581. for (i in seq_along(file_paths)) {
  582. df <- read.csv(file_paths[i])
  583. df$Epochs <- epochs[i]
  584. df$samples <- 100
  585. res_list[[i]] <- df
  586. }
  588. # Combine all data frames
  589. bmk_ctgan <- bind_rows(res_list)
  591. bmk_ctgan$Epochs <- as.factor(bmk_ctgan$Epochs)
  594. # Synthpop
  595. bmk_synthpop <- read.csv("~/Python/WASP-DDLS/SE-benchmark/adni_plus/bmk_new_synthpop.csv") %>% mutate(
  596. Epochs = 0,
  597. samples = 100
  598. )
  600. # TabPFN
  601. bmk_tabpfn <- read.csv("~/Python/WASP-DDLS/SE-benchmark/adni_plus/bmk_new_tabpfn_t_1.0.csv")
  604. label_list = c("DS (100)", "DS w/o DP", "CTGAN (default)", "Synthpop", "TabPFN (t=1.0)")
  607. util_df_adni_plus <- rbind(select(bmk_ds, dataset, model, all_of(util_cols)),
  608. select(bmk_ctgan, dataset, model, all_of(util_cols)),
  609. select(bmk_synthpop, dataset, model, all_of(util_cols)),
  610. select(bmk_tabpfn, dataset, model, all_of(util_cols))
  611. ) |>
  612. dplyr::mutate(avg_F1_diff_value = abs(avg_F1_diff_value),
  613. avg_F1_diff_hout_value = abs(avg_F1_diff_hout_value)) |>
  614. dplyr::mutate(mutual_inf_diff = 1 - tanh(mutual_inf_diff_value),
  615. ks_tvd_stat = 1 - ks_tvd_stat_value,
  616. frac_ks_sigs = 1 - frac_ks_sigs_value,
  617. avg_F1_diff = 1 - abs(avg_F1_diff_value),
  618. avg_F1_diff_hout = 1 - abs(avg_F1_diff_hout_value),
  619. nnaa = 1 - nnaa_value)
  620. util_df_adni_plus$util_score <- util_df_adni_plus |> dplyr::select(c(mutual_inf_diff, ks_tvd_stat, frac_ks_sigs, avg_F1_diff, avg_F1_diff_hout, nnaa)) |> rowMeans()
  622. util_df_adni_plus$Method <- factor(util_df_adni_plus$dataset, levels = unique(util_df_adni_plus$dataset),
  623. labels=label_list)
  625. priv_df_adni_plus <- rbind(select(bmk_ds, dataset, model, all_of(priv_cols)),
  626. select(bmk_ctgan, dataset, model, all_of(priv_cols)),
  627. select(bmk_synthpop, dataset, model, all_of(priv_cols)),
  628. select(bmk_tabpfn, dataset, model, all_of(priv_cols))
  629. ) |>
  630. dplyr::mutate(priv_loss_nndr = 1 - abs(priv_loss_nndr_value),
  631. priv_loss_nnaa = 1 - abs(priv_loss_nnaa_value),
  632. priv_loss_eps = 1 - abs(priv_loss_eps_value),
  633. hit_rate = 1 - hit_rate_value,
  634. eps_identif_risk = 1 - eps_identif_risk_value,
  635. mia_recall = 1 - mia_recall_value,
  636. att_discl_risk = 1 - att_discl_risk_value)
  637. priv_df_adni_plus$priv_score <- priv_df_adni_plus |> dplyr::select(c(priv_loss_nndr, priv_loss_nnaa, priv_loss_eps, hit_rate, eps_identif_risk, att_discl_risk)) |> rowMeans()
  639. priv_df_adni_plus$Method <- factor(priv_df_adni_plus$dataset, levels = unique(priv_df_adni_plus$dataset),
  640. labels=label_list)
  642. up_df_adni_plus <- util_df_adni_plus |> dplyr::select(c(Method, model, util_score)) |>
  643. dplyr::inner_join(priv_df_adni_plus |> dplyr::select(c(Method, model, priv_score)), by = c("Method", "model"))
  646. colormap <- c(
  647. paletteer_d("rcartocolor::BluYl")[1:2],
  648. paletteer_d("beyonce::X58")[3],
  649. "#663399",
  650. paletteer_d("ggsci::cyan_material")[c(1,3,5,7)]
  651. )
  653. up_plot_adni_plus <- ggplot(data = up_df_adni_plus, aes(x=util_score, y=priv_score, fill=Method)) +
  654. labs(title = "ADNI+", x = "Utility", y = "Privacy") +
  655. #scale_fill_paletteer_d("rcartocolor::BluYl") +
  656. scale_fill_manual(values = colormap) +
  657. theme_minimal()
  658. #ylim(0.7,1.0) + xlim(0.3,0.85)
  660. up_df_adni_ <- up_df_adni %>% filter(Method %in% up_df_adni_plus$Method)
  661. up_plot_adni_plus <- up_plot_adni_plus +
  662. geom_point(pch=21, color="gray", size = 3, data=up_df_adni_, alpha=0.75) +
  663. geom_point(pch=21, color = "black", size=3)
  665. plot(up_plot_adni_plus)
  667. up_plot_adni_plus <- up_plot_adni_plus + theme(plot.margin = margin(5.5, 125, 5.5, 125))
  669. up_plot_all <- ggarrange(up_plot_adni, up_plot_a4, ncol=2, common.legend = TRUE, legend = "right")
  670. up_plot_all <- ggarrange(up_plot_all, up_plot_adni_plus, nrow=2, common.legend = FALSE)
  671. plot(up_plot_all)
  673. ##### Saving and stuff ####
  674. ggsave("~/R/DDLS-plots/up_plot_all.tiff", up_plot_all, width = 10, height = 9, units = "in", dpi = 500)
  677. summary_stats_adni_plus <- up_df_adni_plus %>%
  678. group_by(Method) %>%
  679. dplyr::summarize(
  680. mean_u = mean(util_score),
  681. mean_p = mean(priv_score),
  682. sd_u = sd(util_score),
  683. sd_p = sd(priv_score),
  684. num = n(),
  685. ci_margin_u = qt(0.975, df = n() - 1) * sd(util_score) / sqrt(n()),
  686. ci_margin_p = qt(0.975, df = n() - 1) * sd(priv_score) / sqrt(n()),
  687. ci_lwr_u = mean_u - ci_margin_u,
  688. ci_upr_u = mean_u + ci_margin_u,
  689. ci_lwr_p = mean_p - ci_margin_p,
  690. ci_upr_p = mean_p + ci_margin_p
  691. )
  694. res <- summary_stats_adni %>% inner_join(summary_stats_adni_plus, by='Method', suffix = c('.adni', '.adni_plus')) %>%
  695. mutate(ci.bound_u = (mean_u.adni - mean_u.adni_plus) - 1.96 * sqrt((sd_u.adni^2/num.adni) + (sd_u.adni^2/num.adni)),
  696. ci.bound_p = (mean_p.adni - mean_p.adni_plus) - 1.96 * sqrt((sd_p.adni^2/num.adni) + (sd_p.adni^2/num.adni)))
  698. res <- data.frame()
  699. for(method in unique(up_df_adni_plus$Method)) {
  700. a <- up_df_adni_plus %>% filter(Method == method)
  701. b <- up_df_adni %>% filter(Method == method)
  703. t_u <- t.test(a$util_score, b$util_score, alternative = "two.sided", var.equal=F)
  704. t_p <- t.test(a$priv_score, b$priv_score, alternative = "two.sided", var.equal=F)
  705. res <- rbind(res, data.frame(Method = method,
  706. #t_stat_u = t_u$statistic,
  707. p_value_u = t_u$p.value * nrow(a),
  708. mean_u_x = t_u$estimate[1],
  709. mean_u_y = t_u$estimate[2],
  710. #t_stat_p = t_p$statistic,
  711. p_value_p = t_p$p.value * nrow(a),
  712. mean_p_x = t_p$estimate[1],
  713. mean_p_y = t_p$estimate[2]
  714. ))
  715. }

benchmark.plots.R at commit 299d5c6, under MIT · at the source

Overview

Authors: Filip Winzell1, Ida Arvidsson1, Niels Christian Overgaard1, Anders Heyden1, Kalle Åström1, Linda Karlsson2, Jacob W Vogel3, Oskar Hansson4, Niklas Mattsson‐Carlgren3,4,5, for the Alzheimer's Disease Neuroimaging Initiative
  1. Centre for Mathematical Sciences, Lund University, Lund, Sweden
  2. Clinical Memory Research Unit, Department of Clinical Sciences in Malmö, Lund University, Lund, Sweden
  3. Department of Clinical Sciences Malmö, SciLifeLab, Lund University, Lund, Sweden
  4. Wallenberg Center for Molecular Medicine, Lund University, Lund, Sweden
  5. Memory Clinic, Skåne University Hospital, Malmö, Sweden
Institutions: Lund University (Sweden); Science for Life Laboratory (Sweden); Skåne University Hospital (Sweden)
Journal: Alzheimer's & dementia (Amsterdam, Netherlands), volume 18, issue 3, article e70430
Dates: received 20 October 2025; accepted 18 June 2026; published online 10 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1002/dad2.70430 · PMID 42582267 · PMCID PMC13457355 · OpenAlex W7202110940
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), Alzheimer's / dementia (population), methods / tools (subfield)
Methods: Machine learning, Statistics, Connectivity
Keywords: Alzheimer's disease, machine learning, synthetic data, tabular data
Topic: Privacy-Preserving Technologies in Data (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: European Research Council (101108819); NIA NIH HHS (R01 AG083740, U01 AG024904)
Citations: not cited yet (Europe PMC); 28 references in the paper

Abstract

INTRODUCTION: The scarcity of large, clinically relevant cohorts is becoming a bottleneck in Alzheimer's disease (AD) research, as their sensitive nature makes open data sharing difficult. Privacy‐preserving synthetic datasets generated with machine learning may help address this challenge.

METHODS: We compared five frameworks for generating synthetic tabular data from the Alzheimer's Disease Neuroimaging Initiative and Anti‐Amyloid Treatment in Asymptomatic Alzheimer's Disease cohorts, with a set of empirical privacy and utility metrics. Two of the methods, DataSynthesizer and TableDiffusion, provide ε‐differential privacy guarantees.

RESULTS: Methods with differential privacy achieved high privacy ratings but low levels of utility. Deep learning methods like Tabular Prior‐data Fitted Network (TabPFN) and Conditional Generative Adversarial Network (CTGAN) also showed high privacy with limited utility. In contrast, non‐private DataSynthesizer and Synthpop offered higher utility at a cost of lower privacy.

DISCUSSION: The evaluated methods demonstrated a clear trade‐off between privacy and utility. High privacy was generally associated with insufficient utility, highlighting the need for further research into synthetic data generation for AD.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repository

Its files are read in the Code ↔ Paper reader above, with 7 matches between paragraphs and lines of code.

fwinzell/synthetic_ad

License: MIT
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 299d5c63736fcf624ab4aa5a67f43723c116be7d, 12 February 2026
Languages: R (15), Python (15)
Size: 48 files, 30 scripts
Software Heritage: not archived
Found in: the text, “INTRODUCTION”
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: pandas (14 files), ggplot2 (13 files), NumPy (13 files), tidyverse (13 files), ggpubr (12 files), Matplotlib (8 files), scikit-learn (5 files), NetworkX (2 files), seaborn (2 files), LightGBM (1 file), lme4 (1 file), Plotly (1 file), PyTorch (1 file), SciPy (1 file)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
32 files
At the source: github.com/fwinzell/synthetic_ad

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 30 scripts, each with its path and the digest of its content;
  • 7 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 10 authors, 4 keywords, 2 funders, 26 references.

Cite

This paper

Winzell, F., Arvidsson, I., Overgaard, N. C., Heyden, A., Åström, K., Karlsson, L., Vogel, J. W., Hansson, O., Mattsson‐Carlgren, N., & for the Alzheimer's Disease Neuroimaging Initiative. (2026). Benchmarking privacy and utility in synthetic tabular cohorts for Alzheimer's disease research. Alzheimer's & dementia (Amsterdam, Netherlands), 18(3), e70430. https://doi.org/10.1002/dad2.70430

BibTeX

@article{winzell2026benchmarking,
author = {Winzell, Filip and Arvidsson, Ida and Overgaard, Niels Christian and Heyden, Anders and Åström, Kalle and Karlsson, Linda and Vogel, Jacob W and Hansson, Oskar and Mattsson‐Carlgren, Niklas and {for the Alzheimer's Disease Neuroimaging Initiative}},
title = {{Benchmarking privacy and utility in synthetic tabular cohorts for Alzheimer's disease research}},
journal = {Alzheimer's \& dementia (Amsterdam, Netherlands)},
year = {2026},
month = jul,
volume = {18},
number = {3},
pages = {e70430},
publisher = {Wiley},
issn = {2352-8729},
doi = {10.1002/dad2.70430},
url = {https://doi.org/10.1002/dad2.70430},
pmid = {42582267},
pmcid = {PMC13457355}
}

RIS

TY - JOUR
AU - Winzell, Filip
AU - Arvidsson, Ida
AU - Overgaard, Niels Christian
AU - Heyden, Anders
AU - Åström, Kalle
AU - Karlsson, Linda
AU - Vogel, Jacob W
AU - Hansson, Oskar
AU - Mattsson‐Carlgren, Niklas
AU - for the Alzheimer's Disease Neuroimaging Initiative
TI - Benchmarking privacy and utility in synthetic tabular cohorts for Alzheimer's disease research
T2 - Alzheimer's & dementia (Amsterdam, Netherlands)
J2 - Alzheimers Dement (Amst)
PY - 2026
DA - 2026/07/01
VL - 18
IS - 3
SP - e70430
SN - 2352-8729
PB - Wiley
DO - 10.1002/dad2.70430
UR - https://doi.org/10.1002/dad2.70430
LA - en
ER -

CSL-JSON

{
"id": "10.1002/dad2.70430",
"type": "article-journal",
"title": "Benchmarking privacy and utility in synthetic tabular cohorts for Alzheimer's disease research",
"container-title": "Alzheimer's & dementia (Amsterdam, Netherlands)",
"author": [
{
"family": "Winzell",
"given": "Filip"
},
{
"family": "Arvidsson",
"given": "Ida"
},
{
"family": "Overgaard",
"given": "Niels Christian"
},
{
"family": "Heyden",
"given": "Anders"
},
{
"family": "Åström",
"given": "Kalle"
},
{
"family": "Karlsson",
"given": "Linda"
},
{
"family": "Vogel",
"given": "Jacob W"
},
{
"family": "Hansson",
"given": "Oskar"
},
{
"family": "Mattsson‐Carlgren",
"given": "Niklas"
},
{
"literal": "for the Alzheimer's Disease Neuroimaging Initiative"
}
],
"container-title-short": "Alzheimers Dement (Amst)",
"volume": "18",
"issue": "3",
"page": "e70430",
"DOI": "10.1002/dad2.70430",
"PMID": "42582267",
"PMCID": "PMC13457355",
"ISSN": "2352-8729",
"publisher": "Wiley",
"URL": "https://doi.org/10.1002/dad2.70430",
"language": "en",
"issued": {
"date-parts": [
[
2026,
7,
1
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: NetworkX, Plotly, lme4, 10 other tools
[2] doi:10.1016/j.isci.2026.116055 [code]
Mapping the transcriptional diversity of calcium signaling in the mouse and human brain.
Journal: iScience
In common: LightGBM, NetworkX, Plotly, 9 other tools
[3] doi:10.1093/bioinformatics/btag592 [code]
Network-based stratification of allele-specific expression reveals patient subgroups in Huntington's disease.
Journal: Bioinformatics (Oxford, England)
In common: NetworkX, Plotly, lme4, 9 other tools
[4] doi:10.1016/j.xcrm.2026.102766 [code]
A longitudinal single-cell and spatial multiomic atlas of pediatric high-grade glioma.
Journal: Cell reports. Medicine
In common: NetworkX, Plotly, lme4, 9 other tools
[5] doi:10.1038/s41586-026-10735-w [code]
Distributed control circuits across a brain-and-cord connectome.
Journal: Nature
In common: NetworkX, Plotly, ggpubr, 9 other tools
[6] doi:10.1038/s41467-026-73996-z [code]
Genetic architecture of white matter microstructure captured by unsupervised deep representation learning of fractional anisotropy maps.
Journal: Nature communications
In common: LightGBM, Plotly, PyTorch, 8 other tools
[7] doi:10.1093/braincomms/fcag176 [code]
Tau topography subtypes account for clinical heterogeneity and longitudinal trajectories in early-onset Alzheimer's disease.
Journal: Brain communications
In common: Plotly, lme4, ggpubr, 8 other tools, Alzheimer's / dementia
[8] doi:10.1038/s41514-026-00443-0 [code]
Network-based discovery of regulatory drivers of cognitive decline in alzheimer's disease.
Journal: npj aging
In common: NetworkX, Plotly, ggpubr, 8 other tools, Alzheimer's / dementia
[9] doi:10.1016/j.xcrm.2026.102651 [code]
Integrative CSF profiling identifies disease-specific immune responses in leptomeningeal disease.
Journal: Cell reports. Medicine
In common: NetworkX, Plotly, ggpubr, 8 other tools
[10] doi:10.1038/s41586-026-10629-x [code]
Whole-genome duplication shaped cell-type evolution in the vertebrate brain.
Journal: Nature
In common: NetworkX, lme4, ggpubr, 8 other tools

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.