Single-cell Best Practices

The decision to sequence whole cells versus nuclei is largely driven by the type of tissue being studied and the preservation of cell types.

Single-cell sequencing

• Mechanism: Captures whole cells.
• Risks: Tissue dissociation can be biased. Certain cell types (e.g., specific neurons in the brain) are more vulnerable to mechanical/enzymatic dissociation and may be underrepresented in the final suspension. Requires fresh tissue.

Single-nuclei sequencing

• Mechanism: Captures only the nuclei.
• Strengths: Nuclei are more resistant to mechanical force and can be isolated from frozen tissue (useful for biobanks) without enzymatic dissociation.
• Accuracy: Nuclei have been shown to accurately reflect the transcriptional patterns of the original cells.

Key Consideration: Always discuss experimental design between wet lab and dry lab scientists, as dissociation ability significantly impacts which cell types are observable in the data.

The RAPIDS Memory Manager (RMM) controls how VRAM is allocated. You must pick exactly one strategy and configure it at the very top of your notebook before any CuPy arrays are created.

1. Pool Allocator: Fastest option. Grabs a large slab of VRAM upfront. Use this if your dataset fits entirely in VRAM. Set initial_pool_size close to your expected peak to avoid fragmentation.
2. Managed (Unified) Memory: Use this if your dataset is larger than your VRAM. It uses CUDA managed memory to page data between host RAM and GPU. It is slower but allows analyzing datasets larger than physical VRAM.

Warning: Do not enable both pool_allocator=True and managed_memory=True simultaneously; they conflict and degrade performance.

import cupy as cp
import rmm
from rmm.allocators.cupy import rmm_cupy_allocator

# Strategy 1: Pool Allocator (for datasets that fit in VRAM)
rmm.reinitialize(
    pool_allocator=True,
    managed_memory=False,
    initial_pool_size="4GB",
    maximum_pool_size="32GB",
)
cp.cuda.set_allocator(rmm_cupy_allocator)

# Strategy 2: Managed Memory (for datasets larger than VRAM)
rmm.reinitialize(
    pool_allocator=False,
    managed_memory=True,
)
cp.cuda.set_allocator(rmm_cupy_allocator)

Single-cell sequencing protocols are categorized by how they isolate cells:

Separation in Droplets

These methods encapsulate cells into tiny droplets (emulsions) using microfluidics, enabling massive parallelization and high throughput.

• Common Protocols: inDrop, Drop-seq, and 10x Genomics Chromium.
• Mechanism: Cells and beads (containing cell barcodes, UMIs, and primers) are trapped in droplets. Upon lysis, mRNA is captured by the beads. The droplets are then broken to release transcriptomes attached to microparticles (STAMPs).
• Pros/Cons: High throughput and cost-efficient for large cell numbers, but typically have lower transcript recovery rates (~10%) and capture only the 3' or 5' ends of transcripts.

Separation in Physical Compartments (Plate-based)

These methods isolate cells into individual wells in a microwell plate.

• Mechanism: Cells are typically sorted into wells using techniques like FACS (fluorescence-activated cell sorting) or micro-pipetting. Lysis and reverse transcription then occur within each individual well.
• Pros/Cons: Can achieve higher sensitivity (5,000 to 10,000 captured genes per cell) compared to droplet methods, but is generally lower throughput as it is limited to several hundred cells per experiment.

To perform single-cell quality control (QC) using Scanpy and Lamindb, you need to import several libraries including scanpy, lamindb, seaborn, and rpy2 for R integration. It is recommended to suppress Scanpy's verbose logging and set figure parameters for clean plots.

To load the specific dataset used in this tutorial, use lamindb to connect to the theislab/sc-best-practices instance and retrieve the quality_control_adata.h5ad artifact. Always ensure variable names are unique using adata.var_names_make_unique() to prevent downstream errors.

import lamindb as ln
import numpy as np
import scanpy as sc
import seaborn as sns
from rpy2.robjects import numpy2ri
from rpy2.robjects.conversion import localconverter
from scipy.sparse import csc_matrix
from scipy.stats import median_abs_deviation

# Suppress verbose logging from Scanpy
sc.settings.verbosity = 0

# Set figure parameters for clean, minimal plots
sc.settings.set_figure_params(dpi=80, facecolor="white", frameon=False)

assert ln.setup.settings.instance.slug == "theislab/sc-best-practices"

ln.track()

# Load the dataset
af = ln.Artifact.connect("theislab/sc-best-practices").get(
    key="preprocessing_visualization/quality_control_adata.h5ad", is_latest=True
)
adata = af.load()

# Ensure unique variable names
adata.var_names_make_unique()

For differentiated normalization, the notebook uses the scran R package to compute size factors based on clusters.

Workflow:

1. Preliminary Clustering: Perform standard Scanpy preprocessing (normalize, log1p, PCA, neighbors, Leiden) to create temporary clusters (groups).
2. Transfer to R: Convert the normalized data matrix and the cluster labels to R.
3. Compute Size Factors: In R, use scran::computeSumFactors on a SingleCellExperiment object using the provided clusters.
4. Apply in Python: Retrieve the size_factors from R, add them to adata.obs, and perform the normalization: adata.X / adata.obs["size_factors"].

# 1. Preliminary clustering
adata_pp = adata.copy()
sc.pp.normalize_total(adata_pp)
sc.pp.log1p(adata_pp)
sc.pp.pca(adata_pp, n_comps=15)
sc.pp.neighbors(adata_pp)
sc.tl.leiden(adata_pp, key_added="groups", flavor="igraph", n_iterations=2, directed=False)

# 2. Transfer to R and 3. Compute size factors
%%R -o size_factors
library(scran)
library(BiocParallel)
size_factors = sizeFactors(
    computeSumFactors(
        SingleCellExperiment(list(counts=data_mat)), 
        clusters = input_groups,
        min.mean = 0.1,
        BPPARAM = MulticoreParam()
    )
)

# 4. Apply in Python
adata.obs["size_factors"] = size_factors
scran = adata.X / adata.obs["size_factors"].values[:, None]
scran_logged = np.log1p(scran)
adata.layers["scran_normalization"] = csr_matrix(scran_logged)