Local and Global Stratification Analysis in Whole Genome Sequencing (WGS) Studies Using LocStra

Abstract

We are interested in the analysis of local and global population stratification in WGS studies. We present a new R package (locStra) that utilizes the covariance matrix, the genomic relationship matrix, and the unweighted/weighted genetic Jaccard similarity matrix in order to assess population substructure. The package allows one to use a tailored sliding window approach, for instance using user-defined window sizes and metrics, in order to compare local and global similarity matrices. A technique to select the window size is proposed. Population stratification with locStra is efficient due to its C++ implementation which fully exploits sparse matrix algebra. The runtime for the genome-wide computation of all local similarity matrices does typically not exceed one hour for realistic study sizes. This makes an unprecedented investigation of local stratification across the entire genome possible. We apply our package to the 1,000 Genomes Project.

Appendices

A Details on the Implementation

The appendix provides two implementation details on the fully sparse matrix algebra used in the computations of the covariance and Jaccard matrices. Default implementations were used for the GRM matrix [17] and the s-matrix [14]. We assume $X \in \mathbb {R}^{m \times n}$ for the matrix containing (genomic) data of length m in each of the n columns (one column per individual) throughout the section.

1.1 A.1 Covariance Matrix

We first look at computing the covariance matrix in dense algebra. Let the column means of X be given as vector $v \in \mathbb {R}^n$ and denote as $Y \in \mathbb {R}^{m \times n}$ the matrix consisting of the rows of X with their mean substracted. Then

$$\text {cov}(X) = \frac{1}{m-1} Y^\top Y.$$

In the sparse case, it is not possible to compute $\text {cov}(X)$ as above. This is because normalizing X as above by substracting the column means results in a dense matrix which easily exceeds available memory. Thus the computation is split up suitably to always avoid the creation of dense matrices. Letting v be the column means as above, and $w \in \mathbb {R}^n$ be the column sums,

$$\text {cov}(X) = \frac{1}{m-1} \left( X^\top X - w v^\top - v w^\top + m v v^\top \right) .$$

We observe that computing $X^\top X$ involves only the sparse input matrix and one sparse matrix multiplication (which can be done efficiently). The other three terms are vector-vector products resulting in dense $n \times n$ matrices, the (necessary) size of the output covariance matrix.

1.2 A.2 Jaccard Similarity Matrix

Denoting the ith column of X as $X_i$, each entry (i, j) of the Jaccard matrix is given as

$$\text {jac}(X)_{ij} = \frac{\left| \left\{ k: X_{ik} \wedge X_{jk} \right\} \right| }{\left| \left\{ k: X_{ik} \vee X_{jk} \right\} \right| }.$$

For this we assume that X is binary.

Naïvely, we iterate over all the entries of the Jaccard matrix and compute them as given above using binary and as well as binary or operations. This turned out to be slow in our experiments. The following is a faster way to compute the Jaccard matrix in practice even though the asymptotic runtime is unchanged.

Recall that $w \in \mathbb {R}^n$ denotes the column sums of X. Using sparse matrix multiplication, we compute $Y = X^\top X \in \mathbb {R}^{n \times n}$, which is a dense matrix. Let $Z \in \mathbb {R}^{n \times n}$ be the matrix obtained by adding w to all rows and all columns of $-Y$. Observe that $\text {jac}(X) = Y/Z$, where the matrix division is performed entry-wise. Since we only need one sparse matrix multiplication to compute Y (which can be done efficiently), this approach is computationally very fast. The few other operations on the matrices Y and Z are efficient since both matrices are already of same size as the dense Jaccard output matrix.

Table 1. Theoretical runtimes for computing the four similarity matrices. Runtimes differ between dense and sparse implementations. The parameters are: dimensions $m \in \mathbb {N}$ and $n \in \mathbb {N}$ of the input data $X \in \mathbb {R}^{m \times n}$, matrix sparsity parameter $s \in [0,1]$.

B Theoretical Runtimes

Table 1 shows the theoretical runtimes for both dense and sparse implementations. As can be seen, the theoretical runtimes for the dense computations are equal, but runtimes for sparse implementations differ. A detailed overview of the computations being carried out and their runtimes is given below. All efforts are given in the dimensions $m \in \mathbb {N}$ and $n \in \mathbb {N}$ of the input data $X \in \mathbb {R}^{m \times n}$, and the matrix sparsity parameter $s \in [0,1]$ (the proportion of non-zero matrix entries).

Computing the covariance matrix involves calculating the column means of X and substracting them from the matrix X (O(mn) for the dense case and $O(n^2)$ for the sparse case involving a correction with outer products, see Sect. A.1). Multiplying $Y^\top Y$ takes $O(mn^2)$ in dense and $O(smn^2)$ in sparse algebra.

Computing the Jaccard matrix involves calculating $Y=X^\top X$ ($O(mn^2)$ in dense and $O(smn^2)$ in sparse algebra) and adding the column sums of X (computed in O(mn) in dense and O(smn) in sparse algebra) to all rows and columns ($O(n^2)$ in both dense and sparse algebra).

Computing the weighted Jaccard matrix (or s-matrix) involves calculating the row sums of the input matrix which are used as weights (O(mn) in dense and O(smn) in sparse algebra), componentwise multiplication of all columns with the weights (O(mn) in dense and O(smn) in sparse algebra), and one matrix-matrix multiplication ($O(mn^2)$ in dense and $O(smn^2)$ in sparse algebra).

Computing the GRM matrix involves the calculation of population frequencies across rows (O(mn) in dense and O(smn) in sparse algebra), one matrix-matrix multiplication ($O(mn^2)$ in dense and $O(smn^2)$ in sparse algebra), as well as multiplying the input matrix with the population frequencies (O(mn) in dense and O(smn) in sparse algebra). Additionally, one outer vector product is required ($O(n^2)$ in both dense and sparse algebra).

Table 2. Computation of the global eigenvector (global EV) and complete stratification scan of chromosome 1 of the 1,000 Genome Project as a function of the window size. Runtimes in seconds for locStra and PLINK2.

C Comparison of locStra to PLINK2

Table 2 shows a runtime comparison between locStra and PLINK2. As test data we use chromosome 1 of the 1,000 Genome Project. Before running either locStra or PLINK2, we prepare the raw data from the 1,000 Genome Project using the same parameters as given in Sect. 3. However, locStra and PLINK2 require different input files, and thus we write out the processed data once in the .bed format for PLINK2, and once as .Rdata file containing a sparse matrix of class Matrix in R.

A local stratification scan can be performed in PLINK2: With the command --pca 1, the first eigenvector can be computed for an input .bed file. In order to do a sliding window scan, we use the parameters --from and --to followed by the rs numbers to specify a local window. All eigenvectors are written to an output file with extension .eigenvec by PLINK2, from which we read the vectors and compute correlations in R.

In the locStra package, the local stratification scan is performed using the function fullscan as described in Sect. 2.2.

The results in Table 1 show that even for the computation of the single global eigenvector, locStra is considerably faster than PLINK2. All runtimes for both locStra and PLINK2 include the time to read the .Rdata or .bed input files. For a full scan, PLINK2 needs to (inefficiently) write the eigenvector data for each local window into a file. In comparison to PLINK2, locStra is around one order of magnitude faster, where the speed-up is more pronounced for larger window sizes.