Overview

Mutual nearest neighbors (MNNs) are defined as pairs of cells - one from each batch - that are within each other’s set of k nearest neighbors. The idea is that MNN pairs across batches refer to the same cell type, assuming that the batch effect is orthogonal to the biological subspace (Haghverdi et al. 2018). Once MNN pairs are identified, the difference between the paired cells is used to infer the magnitude and direction of the batch effect. It is then straightforward to remove the batch effect and obtain a set of corrected expression values.

The new, fast method

The fastMNN() function performs a principal components analysis (PCA) on the HVGs to obtain a low-dimensional representation of the input data. MNN identification and correction is performed in this low-dimensional space, which offers some advantages with respect to speed and denoising. This returns a SingleCellExperiment containing a matrix of corrected PC scores is returned, which can be used directly for downstream analyses such as clustering and visualization. (We set the seed as we default to a stochastic method for PCA - see comments on multiBatchPCA() below.)

library(batchelor)
set.seed(101)
f.out <- fastMNN(A=sce1, B=sce2, subset.row=chosen.hvgs)
str(reducedDim(f.out, "corrected"))

##  num [1:4464, 1:50] -0.0729 -0.0853 -0.0886 -0.1021 -0.0832 ...
##  - attr(*, "dimnames")=List of 2
##   ..$ : chr [1:4464] "1772071015_C02" "1772071017_G12" "1772071017_A05" "1772071014_B06" ...
##   ..$ : NULL

The batch of origin for each row/cell in the output matrix is also returned:

rle(f.out$batch)

## Run Length Encoding
##   lengths: int [1:2] 2874 1590
##   values : chr [1:2] "A" "B"

Another way to call fastMNN() is to specify the batch manually. This will return a corrected matrix with the cells in the same order as that in the input combined object. In this case, it doesn’t matter as the two batches were concatenated to created combined anyway, but these semantics may be useful when cells from the same batch are not contiguous.

set.seed(101)
f.out2 <- fastMNN(combined, batch=combined$batch, subset.row=chosen.hvgs)
str(reducedDim(f.out2, "corrected"))

##  num [1:4464, 1:50] -0.0729 -0.0853 -0.0886 -0.1021 -0.0832 ...
##  - attr(*, "dimnames")=List of 2
##   ..$ : chr [1:4464] "1772071015_C02" "1772071017_G12" "1772071017_A05" "1772071014_B06" ...
##   ..$ : NULL

As we can see, cells from the batches are more intermingled in the t-SNE plot below. This suggests that the batch effect was removed - assuming, of course, that the intermingled cells represent the same population.

set.seed(103)
f.out <- runTSNE(f.out, dimred="corrected")
plotTSNE(f.out, colour_by="batch")

We can also obtain per-gene corrected expression values by using the rotation vectors stored in the output. This reverses the original projection used to obtain the initial low-dimensional representation. There are, however, several caveats to using these values for downstream analyses.

cor.exp <- assay(f.out)[1,]
hist(cor.exp, xlab="Corrected expression for gene 1", col="grey80") 

While the default arguments are usually satisfactory, there are many options for running fastMNN(), e.g., to improve speed or to achieve a particular merge order. Refer to the documentation at ?fastMNN or the book for more details.

The old, classic method

The original method described by Haghverdi et al. (2018) is implemented in the mnnCorrect() method. This performs the MNN identification and correction in the gene expression space, and uses a different strategy to overcome high-dimensional noise. mnnCorrect() is called with the same semantics as fastMNN():

# Using fewer genes as it is much, much slower. 
fewer.hvgs <- head(order(combined.dec$bio, decreasing=TRUE), 100)
classic.out <- mnnCorrect(sce1, sce2, subset.row=fewer.hvgs)

… but returns the corrected gene expression matrix directly, rather than using a low-dimensional representation¹. This is wrapped in a SingleCellExperiment object to store various batch-related metadata.

classic.out

## class: SingleCellExperiment 
## dim: 100 4464 
## metadata(1): merge.info
## assays(1): corrected
## rownames(100): Plp1 Gad1 ... Olfm1 Ndrg4
## rowData names(0):
## colnames(4464): 1772071015_C02 1772071017_G12 ...
##   CAV_VISp_Contra_tdTpos_cell_4 CAV_VISp_Contra_tdTpos_cell_5
## colData names(1): batch
## reducedDimNames(0):
## mainExpName: NULL
## altExpNames(0):

For scRNA-seq data, fastMNN() tends to be both faster and better at achieving a satisfactory merge. mnnCorrect() is mainly provided here for posterity’s sake, though it is more robust than fastMNN() to certain violations of the orthogonality assumptions.

The cluster-based method

In some scenarios, we have already separately characterized the heterogeneity in each batch, identifying clusters and annotating them with relevant biological states. The clusterMNN() function allows us to examine the relationships between clusters across batches, as demonstrated below with the Tasic and Zeisel datasets using the author-provided labels.

# Removing the 'unclassified' cluster, which makes no sense:
not.unclass <- sce2$broad_type!="Unclassified"
clust.out <- clusterMNN(sce1, sce2[,not.unclass],
    subset.row=chosen.hvgs,
    clusters=list(sce1$level1class, sce2$broad_type[not.unclass])) 

The most relevant output is extracted from the metadata and describes the “meta-clusters”, i.e., groupings of matching clusters corresponding to the same biological state across different batches.

clust.info <- metadata(clust.out)$cluster
split(clust.info$cluster, clust.info$meta)

## $`1`
## [1] "astrocytes_ependymal" "Astrocyte"           
## 
## $`2`
## [1] "endothelial-mural" "Endothelial Cell" 
## 
## $`3`
## [1] "interneurons"      "GABA-ergic Neuron"
## 
## $`4`
## [1] "microglia" "Microglia"
## 
## $`5`
## [1] "oligodendrocytes" "Oligodendrocyte" 
## 
## $`6`
## [1] "pyramidal CA1"
## 
## $`7`
## [1] "pyramidal SS"         "Glutamatergic Neuron"
## 
## $`8`
## [1] "Oligodendrocyte Precursor Cell"

The output object itself is a SingleCellExperiment that can be used for downstream processing in the same manner as the output of fastMNN(). Compared to fastMNN(), clusterMNN() is more faithful with respect to preseving the separation between clusters; however, it will not attempt to adjust for differences in intra-cluster structure between batches. This can generally be considered a more conservative strategy than fastMNN() for merging batches.

Selecting genes

As shown above, the subset.row= argument will only perform the correction on a subset of genes in the data set. This is useful for focusing on highly variable or marker genes during high-dimensional procedures like PCA or neighbor searches, mitigating noise from irrelevant genes. For per-gene methods, this argument provides a convenient alternative to subsetting the input.

For some functions, it is also possible to set correct.all=TRUE when subset.row= is specified. This will compute corrected values for the unselected genes as well, which is possible once the per-cell statistics are obtained with the gene subset. With this setting, we can guarantee that the output contains all the genes provided in the input.

Restricted correction

Many functions support the restrict= argument whereby the correction is determined using only a restricted subset of cells in each batch. The effect of the correction is then - for want of a better word - “extrapolated” to all other cells in that batch. This is useful for experimental designs where a control set of cells from the same source population were run on different batches. Any difference in the controls between batches must be artificial in origin, allowing us to estimate and remove the batch effect without making further biological assumptions.

# Pretend the first X cells in each batch are controls.
restrict <- list(1:100, 1:200) 
rescale.out <- rescaleBatches(sce1, sce2, restrict=restrict)

Multi-batch normalization

Differences in sequencing depth between batches are an obvious cause for batch-to-batch differences. These can be removed by multiBatchNorm(), which downscales all batches to match the coverage of the least-sequenced batch. This function returns a list of SingleCellExperiment objects with log-transformed normalized expression values that can be directly used for further correction.

normed <- multiBatchNorm(A=sce1, B=sce2,
    norm.args=list(use_altexps=FALSE))
names(normed)

## [1] "A" "B"

Downscaling mitigates differences in variance between batches due to the mean-variance relationship of count data. It is achieved using a median-based estimator to avoid problems with composition biases between batches (Lun, Bach, and Marioni 2016). Note that this assumes that most genes are not DE between batches, which we try to avoid violating by performing the rescaling on all genes rather than just the HVGs.

Multi-batch PCA

Users can perform a PCA across multiple batches using the multiBatchPCA() function. The output of this function is roughly equivalent to cbinding all batches together and performing PCA on the merged matrix. The main difference is that each sample is forced to contribute equally to the identification of the rotation vectors. This allows small batches with unique subpopulations to participate in the definition of the low-dimensional space.

set.seed(100)

# Using the same BSPARAM argument as fastMNN(), for speed.
pca.out <- multiBatchPCA(A=sce1, B=sce2, subset.row=chosen.hvgs,
    BSPARAM=BiocSingular::IrlbaParam(deferred=TRUE))
names(pca.out)

## [1] "A" "B"

This function is used internally in fastMNN() but can be explicitly called by the user. Reduced dimensions can be input into reducedMNN(), which is occasionally convenient as it allows different correction parameters to be repeated without having to repeat the time-consuming PCA step. We use the IRLBA algorithm by default, which means that we need to set seed to guarantee reproducible results. We also set deferred=TRUE to speed up the calculations when using a custom weighting scheme for the batches - see ?"BiocSingular-options" for more details.