Spatial Simulators

Assessing the quality of spatial transcriptomics simulators.

10 datasets · 8 methods · 3 control methods · 46 metrics

Info

Task info Method info Metric info Dataset info Results

Computational methods for spatially resolved transcriptomics (SRT) are frequently developed and assessed through data simulation. The effectiveness of these evaluations relies on the simulation methods’ ability to accurately reflect experimental data. However, a systematic evaluation framework for spatial simulators is lacking. Here, we present SpatialSimBench, a comprehensive evaluation framework that assesses 13 simulation methods using 10 distinct STR datasets.

The research goal of this benchmark is to systematically evaluate and compare the performance of various simulation methods for spatial transcriptomics (ST) data. It aims to address the lack of a comprehensive evaluation framework for spatial simulators and explore the feasibility of leveraging existing single-cell simulators for ST data. The experimental setup involves collecting public spatial transcriptomics datasets and corresponding scRNA-seq datasets. The spatial and scRNA-seq datasets can originate from different study but should consist of similar cell types from similar tissues.

Summary

function aggregate_scores(obj) {
  return d3.mean(obj.map(val => {
    if (val.score === undefined || isNaN(val.score)) return 0;
    return Math.min(1, Math.max(0, val.score))
  }));
}

function transpose_list_of_objects(list) {
  return Object.fromEntries(Object.keys(list[0]).map(key => [key, list.map(d => d[key])]))
}

function label_time(time) {
  if (time < 1e-5) return "0s";
  if (time < 1) return "<1s";
  if (time < 60) return `${Math.floor(time)}s`;
  if (time < 3600) return `${Math.floor(time / 60)}m`;
  if (time < 3600 * 24) return `${Math.floor(time / 3600)}h`;
  if (time < 3600 * 24 * 7) return `${Math.floor(time / 3600 / 24)}d`;
  return ">7d"; // Assuming missing values are encoded as NaN
}

function label_memory(x_mb, include_mb = true) {
  if (!include_mb && x_mb < 1e3) return "<1G";
  if (x_mb < 1) return "<1M";
  if (x_mb < 1e3) return `${Math.round(x_mb)}M`;
  if (x_mb < 1e6) return `${Math.round(x_mb / 1e3)}G`;
  if (x_mb < 1e9) return `${Math.round(x_mb / 1e6)}T`;
  return ">1P";
}

function mean_na_rm(x) {
  return d3.mean(x.filter(d => !isNaN(d)));
}

poss_dataset_ids = dataset_info
  .map(d => d.dataset_id)
  .filter(d => results.map(r => r.dataset_id).includes(d))
poss_method_ids = method_info
  .map(d => d.method_id)
  .filter(d => results.map(r => r.method_id).includes(d))
poss_metric_ids = metric_info
  .map(d => d.metric_id)
  .filter(d => results.map(r => Object.keys(r.scaled_scores)).flat().includes(d))

has_resources = results[0].hasOwnProperty("resources")
has_exit_codes = results[0].hasOwnProperty("exit_codes")

results_long = results.flatMap(d => {
  return Object.entries(d.scaled_scores).map(([metric_id, value]) =>
    ({
      method_id: d.method_id,
      dataset_id: d.dataset_id,
      metric_id: metric_id,
      score: value
    })
  )
}).filter(d => method_ids.includes(d.method_id) && metric_ids.includes(d.metric_id) && dataset_ids.includes(d.dataset_id))

overall = d3.groups(results_long, d => d.method_id)
  .map(([method_id, values]) => ({method_id, mean_score: aggregate_scores(values)}))

per_dataset = d3.groups(results_long, d => d.method_id)
  .map(([method_id, values]) => {
    const datasets = d3.groups(values, d => d.dataset_id)
      .map(([dataset_id, values]) => ({["dataset_" + dataset_id]: aggregate_scores(values)}))
      .reduce((a, b) => ({...a, ...b}), {})
    return {method_id, ...datasets}
  })

per_metric = d3.groups(results_long, d => d.method_id)
  .map(([method_id, values]) => {
    const metrics = d3.groups(values, d => d.metric_id)
      .map(([metric_id, values]) => ({["metric_" + metric_id]: aggregate_scores(values)}))
      .reduce((a, b) => ({...a, ...b}), {})
    return {method_id, ...metrics}
  })

results_resources = {
  let results_resources = null

  if (has_resources) {
    results_resources = results.flatMap(d => {
      return ({
        method_id: d.method_id,
        dataset_id: d.dataset_id,
        ...d.resources
      })
    }).filter(d => method_ids.includes(d.method_id) && dataset_ids.includes(d.dataset_id))
  }

  return results_resources
}

resources = {
  let resources = null

  if (has_resources) {
    resources = d3.groups(results_resources, d => d.method_id)
      .map(([method_id, values]) => {
        const mean_peak_memory_mb = mean_na_rm(values.map(d => d.peak_memory_mb))
        const mean_disk_read_mb = mean_na_rm(values.map(d => d.disk_read_mb))
        const mean_disk_write_mb = mean_na_rm(values.map(d => d.disk_write_mb))
        const mean_duration_sec = mean_na_rm(values.map(d => d.duration_sec))

        return ({
          method_id,
          mean_cpu_pct: mean_na_rm(values.map(d => d.cpu_pct)),
          mean_peak_memory_mb,
          mean_peak_memory_log: -Math.log10(mean_peak_memory_mb),
          mean_peak_memory_str: " " + label_memory(mean_peak_memory_mb) + " ",
          mean_disk_read_mb: mean_na_rm(values.map(d => d.disk_read_mb)),
          mean_disk_read_log: -Math.log10(mean_disk_read_mb),
          mean_disk_read_str: " " + label_memory(mean_disk_read_mb) + " ",
          mean_disk_write_mb: mean_na_rm(values.map(d => d.disk_write_mb)),
          mean_disk_write_log: -Math.log10(mean_disk_write_mb),
          mean_disk_write_str: " " + label_memory(mean_disk_write_mb) + " ",
          mean_duration_sec,
          mean_duration_log: -Math.log10(mean_duration_sec),
          mean_duration_str: " " + label_time(mean_duration_sec) + " "
        })
      })
  }

  return resources
}

exit_codes = {
  let exit_codes = null

  if (has_exit_codes) {
    exit_codes = results.flatMap(d => {
      return ({
        method_id: d.method_id,
        dataset_id: d.dataset_id,
        exit_codes: Object.values(d.exit_codes)
      })
    }).filter(d => method_ids.includes(d.method_id) && dataset_ids.includes(d.dataset_id))
  } else {
    exit_codes = results_resources.flatMap(d => {
      let exit_code = d.exit_code
      if (exit_code === undefined) {
        // If there is not exit code, assume the method ran successfully
        exit_code = 0
      }

      return ({
        method_id: d.method_id,
        dataset_id: d.dataset_id,
        exit_codes: [exit_code]
      })
    }).filter(d => method_ids.includes(d.method_id) && dataset_ids.includes(d.dataset_id))
  }

  return exit_codes
}

error_reasons = d3.groups(exit_codes, d => d.method_id)
  .map(([method_id, values]) => {
    const all_codes = values.flatMap(d => d.exit_codes)

    if (all_codes.length === 0) {
      return {method_id, error_reason: []}
    }

    const error_pct_oom = d3.mean(all_codes, d => d === 137)
    const error_pct_timeout = d3.mean(all_codes, d => d === 143)
    const error_pct_na = d3.mean(all_codes, d => d === 99)
    const error_pct_error = d3.mean(all_codes, d => d > 0) - error_pct_oom - error_pct_timeout - error_pct_na
    const error_pct_unknown = d3.mean(all_codes, d => d < 0)
    const error_pct_ok = d3.mean(all_codes, d => d === 0)
    return ({
      method_id,
      error_reason: [
        error_pct_oom,
        error_pct_timeout,
        error_pct_error,
        error_pct_unknown,
        error_pct_na,
        error_pct_ok
      ],
    })
  })

summary_all = method_info
  .filter(d => show_con || !d.is_baseline)
  .filter(d => method_ids.includes(d.method_id))
  .map(method => {
    const method_id = method.method_id
    const method_name = method.method_name
    const mean_score = overall.find(d => d.method_id === method_id).mean_score
    const datasets = per_dataset.find(d => d.method_id === method_id)
    const metrics = per_metric.find(d => d.method_id === method_id)
    const error_reasons_ = error_reasons.find(d => d.method_id === method_id)

    let summary = {
      method_id,
      method_name,
      mean_score,
      ...datasets,
      ...metrics,
      ...error_reasons_
    }

    if (has_resources) {
      const resources_ = resources.find(d => d.method_id === method_id)
      summary = {...summary, ...resources_}
    }
    return summary
  })
  .sort((a, b) => b.mean_score - a.mean_score)

// make sure the first entry contains all columns
column_info = {
  let column_info = [
    {
      id: "method_name",
      name: "Name",
      label: null,
      group: "method",
      geom: "text",
      palette: null
    },
    {
      id: "mean_score",
      name: "Score",
      group: "overall",
      geom: "bar",
      palette: "overall"
    },
    {
      id: "error_reason",
      name: "Error reason",
      group: "overall",
      geom: "pie",
      palette: "error_reason"
    },
    ...dataset_info
      .filter(d => dataset_ids.includes(d.dataset_id))
      .map(
        d => ({
          id: "dataset_" + d.dataset_id,
          name: d.dataset_name,
          group: "dataset",
          geom: "funkyrect",
          palette: "dataset"
        })
      )
      .sort((a, b) => a.name.localeCompare(b.name)),
    ...metric_info
      .filter(d => metric_ids.includes(d.metric_id))
      .map(
        d => ({
          id: "metric_" + d.metric_id,
          name: d.metric_name,
          group: "metric",
          geom: "funkyrect",
          palette: "metric"
        })
      )
      .sort((a, b) => a.name.localeCompare(b.name)),
  ]

  if (has_resources) {
    column_info.push(
      {
        id: "mean_cpu_pct",
        name: "%CPU",
        group: "resources",
        geom: "funkyrect",
        palette: "resources"
      },
      {
        id: "mean_peak_memory_log",
        name: "Peak memory",
        label: "mean_peak_memory_str",
        group: "resources",
        geom: "rect",
        palette: "resources"
      },
      {
        id: "mean_disk_read_log",
        name: "Disk read",
        label: "mean_disk_read_str",
        group: "resources",
        geom: "rect",
        palette: "resources"
      },
      {
        id: "mean_disk_write_log",
        name: "Disk write",
        label: "mean_disk_write_str",
        group: "resources",
        geom: "rect",
        palette: "resources"
      },
      {
        id: "mean_duration_log",
        name: "Duration",
        label: "mean_duration_str",
        group: "resources",
        geom: "rect",
        palette: "resources"
      }
    )
  }

  column_info = column_info.map(d => {
    if (d.id === "method_name") {
      return {...d, options: {width: 15, hjust: 0}}
    } else if (d.id === "is_baseline") {
      return {...d, options: {width: 1}}
    } else if (d.geom === "bar") {
      return {...d, options: {width: 4}}
    } else {
      return d
    }
  })

  return column_info
}

column_groups = {
  let column_groups = [
    {
      group: "method",
      palette: null,
      level1: ""
    },
    {
      group: "overall",
      palette: "overall",
      level1: "Overall"
    },
    {
      group: "error_reason",
      palette: "error_reason",
      level1: "Error reason"
    },
    {
      group: "dataset",
      palette: "dataset",
      level1: dataset_info.length >= 3 ? "Datasets" : ""
    },
    {
      group: "metric",
      palette: "metric",
      level1: metric_info.length >= 3 ? "Metrics" : ""
    }
  ]

  if (has_resources) {
    column_groups.push(
      {group: "resources", palette: "resources", level1: "Resources"}
    )
  }

  return column_groups
}

palettes = [
  {
    overall: "Greys",
    dataset: "Blues",
    metric: "Reds",
    resources: "YlOrBr",
    error_reason: {
      colors: ["#8DD3C7", "#FFFFB3", "#BEBADA", "#fdb462", "#999999", "#FFFFFF"],
      names: [
        "Memory limit exceeded",
        "Time limit exceeded",
        "Execution error",
        "Unknown error",
        "Not applicable",
        "No error"
      ]
    }
  }
][0]

funkyheatmap(
    transpose_list_of_objects(summary_all),
    transpose_list_of_objects(column_info),
    [],
    transpose_list_of_objects(column_groups),
    [],
    palettes,
    {
        fontSize: 14,
        rowHeight: 26,
        rootStyle: 'max-width: none',
        colorByRank: color_by_rank,
        theme: {
            oddRowBackground: 'var(--bs-body-bg)',
            evenRowBackground: 'var(--bs-button-hover)',
            textColor: 'var(--bs-body-color)',
            strokeColor: 'var(--bs-body-color)',
            headerColor: 'var(--bs-body-color)',
            hoverColor: 'var(--bs-body-color)'
        }
    },
    scale_column
);

Figure 1: Overview of the results per method. This figures shows the mean of the scaled scores (group Overall), the mean scores per dataset (group Dataset) and the mean scores per metric (group Metric).

Display settings

viewof color_by_rank = Inputs.toggle({label: "Color by rank:", value: true})
viewof scale_column = Inputs.toggle({label: "Minmax column:", value: false})
viewof show_con = Inputs.toggle({label: "Show control methods:", value: true})

Filter datasets

viewof dataset_ids = Inputs.checkbox(
  dataset_info.filter(d => poss_dataset_ids.includes(d.dataset_id)),
  {
    keyof: d => d.dataset_name,
    valueof: d => d.dataset_id,
    value: dataset_info.map(d => d.dataset_id),
    label: "Datasets:"
  }
)

Filter methods

viewof method_ids = Inputs.checkbox(
  method_info.filter(d => poss_method_ids.includes(d.method_id)),
  {
    keyof: d => d.method_name,
    valueof: d => d.method_id,
    value: method_info.map(d => d.method_id),
    label: "Methods:"
  }
)

Filter metrics

viewof metric_ids = Inputs.checkbox(
  metric_info.filter(d => poss_metric_ids.includes(d.metric_id)),
  {
    keyof: d => d.metric_name,
    valueof: d => d.metric_id,
    value: metric_info.map(d => d.metric_id),
    label: "Metrics:"
  }
)

funkyheatmap = (await require('d3@7').then(d3 => {
  window.d3 = d3;
  window._ = _;
  return import('https://unpkg.com/funkyheatmapjs@0.2.5');
})).default;

Results

Results table of the scores per method, dataset and metric (after scaling). Use the filters to make a custom subselection of methods and datasets. The “Overall mean” dataset is the mean value across all datasets.

Dataset info

Show

Hindlimbmuscle

Data source · 14-03-2025 · 19.16 MiB

Spatial RNA sequencing of regenerating mouse hindlimb muscle (McKellar_2020?).

The spatial transcriptomics datasets regenerates mouse muscle tissue generated with the 10x Genomics Visium platform.

Brain

Data source · 14-03-2025 · 42.61 MiB

10X Visium spatial RNA-seq from adult mouse brain sections paired to single-nucleus RNA-seq (Kleshchevnikov_2022?).

This datasets were generated matched single nucleus (sn, this submission) and Visium spatial RNA-seq (10X Genomics) profiles of adjacent mouse brain sections that contain multiple regions from the telencephalon and diencephalon.

Cortex

Data source · 14-03-2025 · 19.33 MiB

Scripts and source data for image processing, barcode calling, and cell type annotations in a seqFISH+ experiment (Eng_2019?).

The dataset includes processed image data, cell type annotations with Louvain clusters, gene IDs for transcript locations, and mRNA point locations, with additional data available on Zenodo.

Prostate

Data source · 14-03-2025 · 19.69 MiB

Spatially resolved gene expression of human protate tissue slices treated with steroid hormones for 8 hours (McCray_2021?).

Spatially resolved gene expression was prepard by dissociated hman prostate tissue to single cells, and collected & prepped for RNA-seq using the Visium Spatial Gene Expression kit.

Breast

Data source · 14-03-2025 · 22.65 MiB

A spatially resolved atlas of human breast cancers (Wu_2021?).

This study presents a spatially resolved transcriptomics analysis of human breast cancers.

pancreatic ductal adenocarcinomas

Data source · 14-03-2025 · 17.55 MiB

Integrating microarray-based spatial transcriptomics and single-cell RNA-seq reveals tissue architecture in pancreatic ductal adenocarcinomas (McKellar_2020?).

We developed a multimodal intersection analysis method combining scRNA-seq with spatial transcriptomics to map and characterize the spatial organization and interactions of distinct cell subpopulations in complex tissues, such as primary pancreatic tumors..

Olfactorybulb

Data source · 14-03-2025 · 2.23 MiB

Single-cell and spatial transcriptomic of mouse olfactory bulb (St_hl_2016?).

Single-cell and spatial transcriptomic of mouse olfactory bulb

Fibrosarcoma

Data source · 14-03-2025 · 27.16 MiB

Multi-resolution deconvolution of spatial transcriptomics data reveals continuous patterns of Tumor A1 of Tissue 1 (Lopez_2022?).

Spatial transcriptomics of Tumor A1 of Tissue 1.

Gastrulation

Data source · 14-03-2025 · 14.96 MiB

single-cell and spatial transcriptomic molecular map of mouse gastrulation (Lohoff_2021?).

Single-Cell omics Data across Mouse Gastrulation and Highly multiplexed spatially resolved gene expression profiling of Early Organogenesis.

Osteosarcoma

Data source · 14-03-2025 · 20.11 MiB

Spatial profiling of human osteosarcoma cells (Xia_2019?).

Spatial transcriptome profiling by MERFISH reveals subcellular RNA compartmentalization and cell cycle-dependent gene expression.

Method info

Show

scDesign2

Documentation · Repository · Source Code · Container · build_main

A transparent simulator that generates high-fidelity single-cell gene expression count data with gene correlations captured (Sun_2021?)

scDesign2 is a transparent simulator that achieves all three goals (preserving genes, capturing gene correlations, and generating any number of cells with varying sequencing depths) and generates high-fidelity synthetic data for multiple single-cell gene expression count-based technologies.

scDesign3 (NB)

Documentation · Repository · Source Code · Container · build_main

A probabilistic model that unifies the generation and inference for single-cell and spatial omics data (Song_2023?)

scDesign3 offers a probabilistic model that unifies the generation and inference for single-cell and spatial omics data. The model’s interpretable parameters and likelihood enable scDesign3 to generate customized in silico data and unsupervisedly assess the goodness-of-fit of inferred cell latent structures (for example, clusters, trajectories and spatial locations).

scDesign3 (Poisson)

Documentation · Repository · Source Code · Container · build_main

A probabilistic model that unifies the generation and inference for single-cell and spatial omics data (Song_2023?)

SPARsim

Documentation · Repository · Source Code · Container · build_main

SPARSim single cell is a count data simulator for scRNA-seq data (Baruzzo_2019?)

SPARSim is a scRNA-seq count data simulator based on a Gamma-Multivariate Hypergeometric model. It allows to generate count data that resembles real data in terms of count intensity, variability and sparsity.

Splatter

Documentation · Repository · Source Code · Container · build_main

A single cell RNA-seq data simulator based on a gamma-Poisson distribution (Zappia_2017?)

The Splat model is a gamma-Poisson distribution used to generate a gene by cell matrix of counts. Mean expression levels for each gene are simulated from a gamma distribution and the Biological Coefficient of Variation is used to enforce a mean-variance trend before counts are simulated from a Poisson distribution.

SRTsim

Documentation · Repository · Source Code · Container · build_main

An SRT-specific simulator for scalable, reproducible, and realistic SRT simulations (Zhu_2023?)

A key benefit of srtsim is its ability to maintain location-wise and gene-wise SRT count properties and preserve spatial expression patterns, enabling evaluation of SRT method performance using synthetic data.

symsim

Documentation · Repository · Source Code · Container · build_main

Simulating multiple faceted variability in single cell RNA sequencing (Zhang_2019?)

SymSim is a simulator for modeling single-cell RNA-Seq data, accounting for three primary sources of variation: intrinsic transcription noise, extrinsic variation from different cell states, and technical variation from measurement noise and bias.

zinbwave

Documentation · Repository · Source Code · Container · build_main

A general and flexible method for signal extraction from single-cell RNA-seq data (Risso_2018?)

ZINB-WaVE is a general and flexible zero-inflated negative binomial model, which leads to low-dimensional representations of the data that account for zero inflation (dropouts), over-dispersion, and the count nature of the data.

Control method info

Show

positive

Documentation · Repository · Source Code · Container · build_main

A positive control method

A positive control method.

negative_shuffle

Documentation · Repository · Source Code · Container · build_main

A negative control method which shuffles the input data

This control method shuffles the input data as a negative control.

negative_normal

Documentation · Repository · Source Code · Container · build_main

A negative control which generates normal distributed data

This control method generates normal distributed data as a negative control. The mean and the sd are defined by the mean and sd of the input data.

Metric info

Show

Category	Name	Value	Condition	Severity
Scaling	Worst score scdesign2 ks_statistic_enrichment_scalef	-129.8837000	worst_score >= -1	✗✗✗
Scaling	Worst score scdesign3_poisson ks_statistic_enrichment_scalef	-59.2387000	worst_score >= -1	✗✗✗
Scaling	Worst score scdesign3_poisson ks_statistic_morans_I	-54.6940000	worst_score >= -1	✗✗✗
Scaling	Worst score scdesign3_poisson ks_statistic_nn_correlation	-20.3592000	worst_score >= -1	✗✗✗
Scaling	Worst score scdesign2 ks_statistic_central_score_scalef	-12.7374000	worst_score >= -1	✗✗✗
Scaling	Worst score scdesign2 ks_statistic_transition_scalef	-12.4357000	worst_score >= -1	✗✗✗
Raw results	Metric 'ks_statistic_efflib_size_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_efflib_size_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_frac_zero_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_frac_zero_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_frac_zero_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_frac_zero_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_lib_fraczero_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_lib_fraczero_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_lib_size_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_lib_size_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_mean_fraczero_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_mean_fraczero_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_mean_var_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_mean_var_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_pearson_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_pearson_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_pearson_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_pearson_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_mean_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_mean_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_mean_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_mean_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_var_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_var_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_var_genes_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_scaled_var_genes_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_tmm_cells_tstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Metric 'ks_statistic_tmm_cells_zstat' %missing	1.0000000	pct_missing <= .1	✗✗✗
Raw results	Method 'scdesign3_nb' %missing	0.7521739	pct_missing <= .1	✗✗✗
Raw results	Dataset 'gastrulation' %missing	0.7430830	pct_missing <= .1	✗✗✗
Raw results	Dataset 'brain' %missing	0.7371542	pct_missing <= .1	✗✗✗
Raw results	Dataset 'pdac' %missing	0.7233202	pct_missing <= .1	✗✗✗
Raw results	Dataset 'prostate' %missing	0.7173913	pct_missing <= .1	✗✗✗
Raw results	Dataset 'hindlimbmuscle' %missing	0.7015810	pct_missing <= .1	✗✗✗

Info

Summary

Results

Dataset info

Hindlimbmuscle

Brain

Cortex

Prostate

Breast

pancreatic ductal adenocarcinomas

Olfactorybulb

Fibrosarcoma

Gastrulation

Osteosarcoma

Method info

scDesign2

scDesign3 (NB)

scDesign3 (Poisson)

SPARsim

Splatter

SRTsim

symsim

zinbwave

Control method info

positive

negative_shuffle

negative_normal

Metric info

clustering_ari

clustering_nmi

svg_recall

svg_precision

ctdeconvolute_rmse

ctdeconcolute_jsd

crosscor_mantel

crosscor_cosine

Fraction of zeros per gene

Fraction of zeros per cell

Library size

Effective library size

TMM

Scaled variance cell

Scaled mean cells

Library size vs fraction zero

Sample Pearson correlation

Scaled variance genes

Scaled mean genes

Gene Pearson correlation

Mean vs variance

Mean vs fraction zero

Fraction of zeros per gene

Fraction of zeros per cell

Library size

Effective library size

TMM

Scaled variance cell

Scaled mean cells

Library size vs fraction zero

Sample Pearson correlation

Scaled variance genes

Scaled mean genes

Gene Pearson correlation

Mean vs variance

Mean vs fraction zero

L statistics

Celltype interaction

Library size

Effective library size

Transition matrix

Centralized score

Neighborhood enrichment

Frobenius norm of transition matrix

Frobenius norm of centralized score

Frobenius norm of neighborhood enrichment

Quality control results

Normalisation visualisation

Authors