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, lineartime 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.
Keywords:
Similarity search; Local alignment; Spaced seed; Heuristic algorithm; SensitivityBackground
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 SmithWaterman 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 socalled "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 polynomialtime 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 bitparallel 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 ith letter of s is denoted s[i]. A multiple spaced seed is a set of seeds S = {s_{1}, s_{2}, ..., 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 polynomialtime 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_{1 }and s_{2}, for each of the possible s_{1} + s_{2}1 overlaps between them, denote by σ_{i }the number of overlapping positions where both seeds have a 1.
The overlap complexity is defined as . The overlap complexity of any seed S = {s_{1},s_{2}, ...,s_{k}} is defined by: As an example, . 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 64bit 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 ANDing 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 64bit integer is computed by iteratively shifting right 8 positions, ANDing with 255 and then using the onesInBytes array. The pseudocode (procedure FASTOC) 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 FASTOC. The pseudocode of the new faster implementation for overlap complexity computation, FASTOC
A slightly faster algorithm is obtained by using a precomputed onesInTwoBytes array that stores the number of 1's in the binary representation of 16bit integers, that is, between 0 and 65536. We shall call this algorithm VFASTOC. We have compared the FASTOC and VFASTOC algorithms with the original one implemented in SpEED in Table 1. The VFASTOC algorithm is the fastest, its running time being up to four times lower than the original. The algorithm VFASTOC is of interest in itself and also replacing the original one with VFASTOC 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_{1},s_{2},..., 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
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 rth 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 }= 1 * 11 and s_{2 }= 1**1*1
We notice that the value of o_{ij}[q] is obtained by counting the number of 1's in a NWSE diagonal of OM_{ij}; precisely, the positions considered are OM_{ij}[r][t] with rt = q  ℓ_{j }+ 1.
The new algorithm for hill climbing, FASTHC, 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 710) without actually changing the OM matrices or σ. The UPDATESIGMA 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 1113). Either way the previous OC is restored (step 14). Once the best swap is found, everything is updated: σ arrays (steps 1516), seeds (step 17), OM matrices (steps 1819), and OCM matrix (steps 2021). The σ arrays are updated before the seeds in order to be able to use the same UPDATESIGMA procedure, that works without the actual swap being performed.
Figure 4. The pseudocode of FASTHC. The pseudocode of the new faster algorithm for the hill climbing heuristic, FASTHC
Figure 5. The pseudocode of OCSIGMA. The pseudocode of the additional function OCSIGMA, used by the main function FASTHC.
Figure 6. The pseudocode of UPDATESIGMA. The pseudocode of the additional function UPDATESIGMA, used by the main function FASTHC
Figure 7. The pseudocode of UPDATEOM. The pseudocode of the additional function UPDATEOM, used by the main function FASTHC
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 UPDATESIGMA and UPDATEOM 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 FASTHC.
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
Additional file 1. This file contains the new seeds computed using the improved heuristic.
Format: PDF Size: 53KB Download file
This file can be viewed with: Adobe Acrobat Reader
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 nonacademics: none
Abbreviations
BLAST: Basic local alignment search tool; OC: Overlap complexity.
Competing interests
The author declares that they have no competing interests.
Authors' contributions
SI designed and implemented the algorithms, performed the experiments, and wrote the manuscript. All authors read and approved the final manuscript.
Availability of supporting data
The data sets supporting the results of this article are included within the article (and its Additional file 1).
Acknowledgements
Research partially supported by a grant from the Natural Sciences and Engineering Research Council of Canada (NSERC).
References

Lipman D, Pearson W: Rapid and sensitive protein similarity searches.
Science 1985, 227(4693):14351441. PubMed Abstract  Publisher Full Text

Altschul SF, Gish W, Miller W, Myers EW, Lipman DJ: Basic local alignment search tool.
J Mol Biol 1990, 215(3):403410. PubMed Abstract

Altschul SF, Madden TL, Schaffer AA, Zhang J, Zhang Z, Miller W, Lipman DJ: Gapped BLAST and PSIBLAST: a new generation of protein database search programs.
Nucleic Acids Res 1997, 25(17):33893402. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Califano A, Rigoutsos I: FLASH: a fast lookup algorithm for string homology.
Computer Vision and Pattern Recognition 1993 Proceedings CVPR'93 1993 IEEE Computer Society Conference on 1993, 353359.

Buhler J: Efficient largescale sequence comparison by localitysensitive hashing.
Bioinformatics 2001, 17(5):419428. PubMed Abstract  Publisher Full Text

Ma B, Tromp J, Li M: PatternHunter: faster and more sensitive homology search.
Bioinformatics 2002, 18(3):440445. PubMed Abstract  Publisher Full Text

Burkhardt S, Kärkkäinen J: Better Filtering with Gapped qGrams.

Brown DG: A survey of seeding for sequence alignments. In In Bioinformatics Algorithms: Techniques and Applications. Edited by Mandoiu I, Zelikovsky A. Hoboken: J. Wiley and Sons Inc; 2007:117142.

Li M, Ma B, Kisman D, Tromp J: PatternHunterII: Highly Sensitive and Fast Homology Search.
J Bioinformatics and Computational Biology 2004, 2(3):417440. Publisher Full Text

Noé L, Kucherov G: YASS: enhancing the sensitivity of DNA similarity search.
Nucleic Acids Res 2005, 33(suppl 2):W540W543. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Homer N, Merriman B, Nelson SF: BFAST: An Alignment Tool for Large Scale Genome Resequencing.
PLoS One 2009, 4(11):e7767. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Rumble SM, Lacroute P, Dalca AV, Fiume M, Sidow A, Brudno M: SHRiMP: Accurate Mapping of Short Colorspace Reads.
PLoS Comput Biol 2009, 5(5):e1000386. PubMed Abstract  Publisher Full Text  PubMed Central Full Text

Feng S, Tillier ER: A fast and flexible approach to oligonucleotide probe design for genomes and gene families.
Bioinformatics 2007, 23(10):11951202. PubMed Abstract  Publisher Full Text

Ma B, Li M: On the complexity of the spaced seeds.
J Comput Syst Sci 2007, 73(7):10241034. Publisher Full Text

Ma B, Yao H: Seed Optimization Is No Easier than Optimal Golomb Ruler Design.

Buhler J, Keich U, Sun Y: Designing seeds for similarity search in genomic DNA In Proceedings of RECOMB'03. New York: ACM; 2003:6775.

Kucherov G, Noé L, Roytberg MA: A Unifying Framework for Seed Sensitivity and its Application to Subset Seeds.
J Bioinformatics and Computational Biology 2006, 4(2):553570. Publisher Full Text

Ilie L, Ilie S, Mansouri Bigvand A: SpEED: fast computation of sensitive spaced seeds.
Bioinformatics 2011, 27(17):24332434. PubMed Abstract  Publisher Full Text

Ilie L, Ilie S: Multiple spaced seeds for homology search.
Bioinformatics 2007, 23(22):29692977. PubMed Abstract  Publisher Full Text