Efficient computation of spaced seeds

Abstract

Background

The most frequently used tools in bioinformatics are those searching for similarities, or local alignments, between biological sequences. Since the exact dynamic programming algorithm is quadratic, linear-time heuristics such as BLAST are used. Spaced seeds are much more sensitive than the consecutive seed of BLAST and using several seeds represents the current state of the art in approximate search for biological sequences. The most important aspect is computing highly sensitive seeds. Since the problem seems hard, heuristic algorithms are used. The leading software in the common Bernoulli model is the SpEED program.

Findings

SpEED uses a hill climbing method based on the overlap complexity heuristic. We propose a new algorithm for this heuristic that improves its speed by over one order of magnitude. We use the new implementation to compute improved seeds for several software programs. We compute as well multiple seeds of the same weight as MegaBLAST, that greatly improve its sensitivity.

Conclusion

Multiple spaced seeds are being successfully used in bioinformatics software programs. Enabling researchers to compute very fast high quality seeds will help expanding the range of their applications.

Background

The most frequently used tools in bioinformatics are those searching for similarities, or local alignments, between biological sequences. This problem can be solved exactly using the dynamic programming algorithm of Smith-Waterman in quadratic time. Many instances, including all database searches, are too large for this approach to be feasible and heuristic algorithms are used instead [1, 2]. The most widely used program in bioinformatics, BLAST [2, 3], is one such tool. It uses the so-called "hit and extend" approach: a hit consists of 11 consecutive matches between two sequences and represents a potential local alignment. The hit is then extended both ways in search for similarity.

It is clear that not all local alignments have to include an identical stretch of length 11. It has been already noticed in [4] and then again in [5] that requiring that the matches are not consecutive increases the chances of finding alignments. The idea of optimizing the way the required matches are placed has been investigated in [6, 7], the latter having used it in a similarity search software, PatternHunter. Much work has been dedicated to spaced seeds. For a survey of earlier work, we refer the reader to [8].

The 11 consecutive matches of BLAST are called a contiguous seed, denoted 11111111111 (for 11 consecutive matches), whereas the one of PatternHunter is a spaced seed, 111*1**1*1**11*111; a 1 represents a match and * a don't care position. The number of 1's represents the weight of the seed. The probability of finding local alignments, under specific conditions, to be made precise later, is called sensitivity.

We notice an essential trade off. Decreasing the number of matches, that is, the weight of the seed, increases the sensitivity but also the number of random hits, decreasing specificity. On the other hand, it is intuitively clear that several different seeds will hit different alignments, thus having increased sensitivity. It has been noticed by [9] that doubling the number of seeds can account for the decrease in weight, thus simultaneously increasing sensitivity without reducing specificity. PatternHunterII [9] uses 16 different seeds of weight 11. For comparison, under similar conditions, the sensitivity of the BLAST, PatterHunter, and PatternHunterII seeds, all of weight 11, are 0.30, 0.47, and 0.92, respectively, a very large difference.

Multiple spaced seeds represent the current state of the art in similarity search and are used by many software programs, in a variety of applications, such as sequence alignment [6, 9, 10], read mapping [11, 12], or oligonucleotide design [13]. It is therefore of great importance to be able to compute seeds with high sensitivity. The only way to find optimal seeds seems to be by trying all possible ones. This brute force approach includes two exponential steps. First, there are exponentially many candidates. Second, computing sensitivity is exponential as well. Therefore, only single seeds can be computed this way. For multiple seeds, since the relevant problems are hard [14, 15], heuristic algorithms must be used. Among many such algorithms, such as Mandala [16] and Iedera [17], only one works in polynomial time: SpEED [18]. SpEED is based on the notion of overlap complexity[19], that is very well correlated with sensitivity but polynomial-time computable. A hill climbing algorithm is used that iteratively swaps a 1 with a * in a random seed in order to improve the overlap complexity.

Our contribution in this paper is to improve the best existing software, SpEED, by increasing its speed and, consequently, the sensitivity of the computed seeds. The first algorithm we give is a bit-parallel algorithm for computing overlap complexity. This is of independent interest and alone can speed up the hill climbing of SpEED significantly. However, we give a better algorithm for this heuristic that improves its speed by one order of magnitude. Several tests are provided to prove these claims. Then, the new implementation is employed to compute improved seeds for PatternHunterII as well as BFAST, as they use some of the most demanding seeds. Finally, we show a very significant improvement of the MegaBLAST seeds. At weight 28 they are significantly larger than everything else, yet we manage to compute up to 16 seeds of this weight, with very large improvement in sensitivity over MegaBLAST.

Spaced seeds

A spaced seed is any string containing 1's and *'s. Since having a * at one end of a seed is not useful, we assume that all seed start and end with a 1. For a seed s, the weight w of s is the number of 1's and the length ℓ is the number of all letters. The i th letter of s is denoted s[i]. A multiple spaced seed is a set of seeds S = {s₁, s₂, ..., s _k }. In the Bernoulli model [9] an alignment is represented as a (random) sequence R of 1's and 0's (matches and mismatches) where the probability p of a match is called similarity. The length N of this region R plays an essential role in the sensitivity. We say that a seed s hits R if there is a position i in R such that, for any j, 0 ≤ j ≤ ℓ-1, if s[j] = 1, then R[i + j] = 1. That means, aligning s with R starting at position j causes all 1's in s to correspond to 1's in R. This definition extends naturally to multiple seeds: S hits if one of its seeds does so.

The sensitivity of s (or S) is then defined as the probability that s (or S, respectively) hits R. It depends on the distribution of matches in the seed as well as on the length N of the region to be hit and the similarity level p. The sensitivity can be computed by the dynamic programming (exponential) algorithm given in [9].

Overlap complexity

Since the number of expected seeds is proportional to the weight of a seed, it is fair to compare seeds of the same weight. Thus, given two seeds of weight w, one contiguous and one spaced, the spaced one may have higher sensitivity because its hits do not overlap as much and are therefore better distributed, covering more similarities. The distribution of the 1's is nevertheless crucial for the quality of the seed. For instance, periodically spaced seeds are worse than contiguous. The problem of finding optimal seeds seems difficult and heuristic algorithms are employed. The only polynomial-time algorithm, implemented in SpEED [18], is based on the notion of overlap complexity[19], that captures the amount of overlaps between hits. Given two seeds s₁ and s₂, for each of the possible |s₁| + |s₂|-1 overlaps between them, denote by σ _i the number of overlapping positions where both seeds have a 1.

The overlap complexity is defined as ${\text{OC}}_{(s_1,s_2)}={\displaystyle {\sum }_i{2}^{{\sigma }_i}}$. The overlap complexity of any seed S = {s₁,s₂, ...,s _k } is defined by: $\mathsf{\text{O}}{\mathsf{\text{C}}}_{\left(S\right)}={\sum }_{i\le j}\mathsf{\text{O}}{\mathsf{\text{C}}}_{\left(s_i,s_j\right)}$ As an example, $\mathsf{\text{O}}{\mathsf{\text{C}}}_{\left(1*11,1**1*1\right)=2^1+2^0+2^2+2^1+2^1+2^2+2^0+2^1+2^1=20}$. The overlaps are shown in Figure 1.

Figure 1

Overlap complexity example. An example of the overlap complexity between two spaced seeds. Letters not taking part in the overlaps are grey and the overlapping pairs of 1's are underlined; the values of σ for each overlap are given in the last column

A very strong experimental correlation between overlap complexity and sensitivity has been observed in [19]. Seeds with low overlap complexity have high sensitivity. The algorithm of [18] employs a hill climbing algorithm to constructs highly sensitive seeds. Iteratively, (1, *) pairs are swapped to reduce the overlap complexity of a random seed (see [18] for details). The SpEED software runs much faster and produces better seeds than all the other programs.

Faster overlap complexity

Our first algorithm computes the overlap complexity faster than the one in [18, 19]. It first converts each seed into 64-bit integers by interpreting 1 and * as bits 1 and 0, respectively. For instance, 1**11 is converted into the integer 10011 = 19. The overlap between two seeds is then computed by shifting the bits and AND-ing the integer representation of the seeds. In order to compute the number of 1's in an integer, we assume a precomputed array onesInBytes with 256 components such that onesInBytes[i] given the number of 1's in the binary representation of i. Then, the number of 1's in a 64-bit integer is computed by iteratively shifting right 8 positions, AND-ing with 255 and then using the onesInBytes array. The pseudocode (procedure Fast OC) is given in Figure 2. For simplicity, the computation of the overlap complexity of a single seed is shown. It extends immediately to any multiple seed.

Figure 2

The pseudocode of F ast OC. The pseudocode of the new faster implementation for overlap complexity computation, Fast OC

A slightly faster algorithm is obtained by using a precomputed onesInTwoBytes array that stores the number of 1's in the binary representation of 16-bit integers, that is, between 0 and 65536. We shall call this algorithm VFast OC. We have compared the FAst OC and VFast OC algorithms with the original one implemented in SpEED in Table 1. The VFast OC algorithm is the fastest, its running time being up to four times lower than the original. The algorithm VFast OC is of interest in itself and also replacing the original one with VFast OC would improve the speed of the heuristic correspondingly. However, we give a better solution in the next subsection.

Table 1 Comparison of overlap complexity computation algorithms

Faster hill climbing

The heuristic of SpEED uses a hill climbing algorithm that gradually improves a multiple seed by swapping a 1 with a * in order to reduce as much as possible the overlap complexity. In this section we give a faster algorithm for this hill climbing heuristic. Assume a multiple seed S = {s₁,s₂,..., s _k } each of weight w and denote the length of s _i by ℓ _i , for 1 ≤ i ≤ k. We shall construct, for each pair (i,j) with 1 ≤ i ≤ j ≤ k, an ℓ _i × ℓ _j matrix OM _ij defined by

$$\mathsf{\text{O}}{\mathsf{\text{M}}}_{ij}\left[r\right]\left[q\right]=\left\{\begin{array}{cc}1,\hfill & \hfill \mathsf{\text{if}}{s}_i\left[r\right]=s_j\left[q\right]=1,\hfill \\ 0,\hfill & \hfill \mathsf{\text{if}}{s}_i\left[r\right]=s_j\left[q\right]=0,\hfill \\ -1,\hfill & \hfill \mathsf{\text{otherwise}}.\hfill \end{array}\right.$$

We also consider an array σ _ij of size ℓ _i + ℓ _j - 1 defined as follows. The two seeds s _i and s _j can overlap in ℓ _i + ℓ _j - 1 ways, each identified by the distance r between the right end of s _j and left end of s _i ; we have 0 ≤ r ≤ ℓ _i + ℓ _j - 2. We then define σ _ij [q] to be the number of positions where both seeds have a 1 for the r th overlap. We shall also store a k × k matrix OCM where OCM[i][j] = OC(s _i , s _j ), for all 1 ≤ i ≤ j ≤ k. An example of the above data structures is shown in Figure 3.

Figure 3

An example of the data structures used in the new algorithm for hill climbing. The matrices OM and OCM and the σ arrays are given for the seeds s₁ = 1 * 11 and s₂ = 1**1*1

We notice that the value of o _ij [q] is obtained by counting the number of 1's in a NW-SE diagonal of OM _ij ; precisely, the positions considered are OM _ij [r][t] with r-t = q - ℓ _j + 1.

The new algorithm for hill climbing, Fast HC, works as follows; the pseudocode is shown in Figure 4 with the additional functions given in Figures 5, 6, and 7. First, all matrices and arrays as above are computed according to their definitions (step 1). Then, for all seeds s _q (step 4) and all pairs of positions in each with a 1 (at position i) and a * (at position j) (step 5), the potential reduction in OC is computed (steps 7-10) without actually changing the OM matrices or σ. The Update Sigma procedure computes in linear time the new σ obtained assuming a swap between positions i and j in s _q . If a better OC than the current best is obtained, the current seed and positions are stored together with the new best OC (steps 11-13). Either way the previous OC is restored (step 14). Once the best swap is found, everything is updated: σ arrays (steps 15-16), seeds (step 17), OM matrices (steps 18-19), and OCM matrix (steps 20-21). The σ arrays are updated before the seeds in order to be able to use the same Update Sigma procedure, that works without the actual swap being performed.

Figure 4

The pseudocode of F ast HC. The pseudocode of the new faster algorithm for the hill climbing heuristic, Fast HC

Figure 5

The pseudocode of OCS igma. The pseudocode of the additional function OCSigma, used by the main function Fast HC.

Figure 6

The pseudocode of U pdate S igma. The pseudocode of the additional function Update Sigma, used by the main function Fast HC

Figure 7

The pseudocode of U pdate OM. The pseudocode of the additional function Update OM, used by the main function Fast HC

To simplify the code, we employ the convention that any time we use σ _rq , OM _rq , or OCM[r][q], we assume r < q, otherwise, we would use q, r instead.

A difference needs to be made in both Update Sigma and Update OM between the case r < q and r = q, since in the former the swap affects only one seed whereas in the latter it affects both. Notice also that the value of max(OM _rq [t][i],0) is 1 when (OM _rq [t][i],0) = 1 and 0 otherwise. Therefore, only when the previous value was 1 we subtract 1 from the appropriate component of σ. The value min(OM _rq [t][i],0) is -1 only when OM _rq [t][i] = -1 and, since a swap would cause this -1 to become a 1, the corresponding component of σ is incremented. Two other values, min(-OM _rq [t][i],0) and max(-OM _rq [t][i]), behave similarly. For the code of OCSigma it is sufficient to observe that (1 ≪ σ[t]) = 2^σ[t].

Results

The new implementation of the hill climbing heuristic is one order of magnitude faster than the current implementation in SpEED. The results are summarized in Table 2, for a variety of parameters.

Table 2 Comparison of hill climbing algorithms

We apply the new implementation to compute better seeds for PatternHunterII and BFAST. The results are presented in Tables 3 and 4. The new seeds are better than those computed by Mandala, Iedera, and SpEED. For comparison we present also the single seeds of the same weight, both contiguous and spaced. The single spaced seeds in the case of BLAST have been computed also using Fast HC.

Table 3 Sensitivity comparison of computed spaced seeds for PatternHunter

Table 4 Sensitivity comparison of computed spaced seeds for BFAST

Finally, we have computed several very heavy multiple seeds, using the weight of the default seed of MegaBLAST; see Table 5. We notice the low sensitivity of the MegaBLAST contiguous seed. Even at similarity 90% and length of the similar region sought for 200, the sensitivity is only around 67%. We have computed sets of 1, 2, 4, 8, and 16 seeds with the given weight 28, similarity 90% and N ∈ {100, 150, 200}. The improvement in sensitivity over MegaBLAST is very large. Whereas the sensitivity of the MegaBLAST seed for the given parameters ranges from 39% to 67%, we need 16, 2, and 1 seeds, respectively, to reach sensitivities over 95%. All new seeds we computed are given in the Additional file 1 newSeeds.pdf.

Table 5 Sensitivity comparison of computed spaced seeds of MegaBLAST weight

Discussion

We have provided a much faster implementation of the hill climbing heuristic of SpEED, the leading software for computing multiple spaced seeds in the Bernoulli model. Using the new implementation, some of the most challenging seeds have been improved and new, even more difficult ones, were provided. Still, many problems remain open in this important area. A modified heuristic is needed to be able to compare seeds of different lengths, as well as to address models different from Bernoulli.

Availability and requirements

Project name: SpEEDfast

Project home page: math.ryerson.ca/~silvana/SpEEDfast.cpp

Operating system(s): Platform independent

Programming language: C/C++

Other requirements: none

License: GNU GPL

Any restrictions to use by non-academics: none

Availability of supporting data

The data sets supporting the results of this article are included within the article (and its Additional file 1).