Hirschberg's Algorithm Research Articles

AFMC: An alignment framework for multiple computing services and providers

SummaryThe Hirschberg algorithm is commonly used for protein sequence alignment, which is a very important task in bioinformatics. This article presents the AFMC framework for using the Hirschberg method to perform sequence alignment in multiple cloud computing services of different models, such as Infrastructure‐as‐a‐Service and Function‐as‐a‐Service (FaaS). Experiments were carried out in which several instances of AWS EC2, Azure VMs and Google Compute Engine as well as varied configurations of AWS Lambda, Azure Function, and Google Cloud Function were used to pairwise align COVID‐19 spike proteins. The services were submitted to different levels of simultaneity to align the genetic sequences. The findings reveal that there is a tradeoff between predicted execution time and cost for this application, for example, FaaS‐oriented cloud service models generally took less time to process the workloads. On the other hand, it was observed that, as the level of concurrence increased, there was a marked augmentation in cost. In this context, a framework that provides multi cloud solutions for bioinformatics such as AFMC is essential.

LongAGE: defining breakpoints of genomic structural variants through optimal and memory efficient alignments of long reads.

SummaryDefining the precise location of structural variations (SVs) at single-nucleotide breakpoint resolution is a challenging problem due to large gaps in alignment. Previously, Alignment with Gap Excision (AGE) enabled us to define breakpoints of SVs at single-nucleotide resolution; however, AGE requires a vast amount of memory when aligning a pair of long sequences. To address this, we developed a memory-efficient implementation—LongAGE—based on the classical Hirschberg algorithm. We demonstrate an application of LongAGE for resolving breakpoints of SVs embedded into segmental duplications on Pacific Biosciences (PacBio) reads that can be longer than 10 kb. Furthermore, we observed different breakpoints for a deletion and a duplication in the same locus, providing direct evidence that such multi-allelic copy number variants (mCNVs) arise from two or more independent ancestral mutations.Availability and implementationLongAGE is implemented in C++ and available on Github at https://github.com/Coaxecva/LongAGE.Supplementary information Supplementary data are available at Bioinformatics online.

Foreword to the special issue of the workshop on high performance computing systems (XVIII Simpósio em Sistemas Computacionais de Alto Desempenho, WSCAD 2017)

Foreword to the special issue of the workshop on high performance computing systems (XVIII Simpósio em Sistemas Computacionais de Alto Desempenho, WSCAD 2017)

On the parallelization of Hirschberg's algorithm for multi‐core and many‐core systems

SummaryFinding the longest common subsequence between two strings in acceptable time frames is crucial to solving various problems in different fields of study. To ensure the optimal solution is found, algorithms based on dynamic programming are employed almost exclusively. While the most commonly adopted algorithm, proposed by Needleman and Wunsch, has quadratic time and space complexity, the linear space complexity of Hirschberg's algorithm favors the comparisons of longer sequences. However, it too has a quadratic time complexity and therefore the effective exploitation of parallelism has become essential. This paper focuses on improving the execution efficiency of Hirschberg's algorithm on multi‐core and many‐core systems. To achieve this goal, first, enhancements to the sequential version are proposed to take advantage of SIMD instructions available on modern processors. Second, the impact on the performance of different parallelization strategies is investigated and evaluated. Results show that combining these two aspects can greatly improve the performance of Hirschberg's algorithm on these architectures. In relation to the original version, speedups of over 46 were achieved on a dual 18‐core server for sequences of 1.6 million characters. Furthermore, experiments with a 68‐core Intel Xeon Phi (many‐core) system obtained speedups of up to 105 for the same sequence size.

A Combined Two Step Approach for Detecting Input Validation Attacks Against Web Applications

Internet becomes a part of our daily life. Almost very service by the internet will be provided with the help of web applications with these we can say that without the web application we cannot do anything over the internet but at the same time web applications are mostly targeted by the hackers. In this paper we present an efficient intrusion detection system approach for detecting input validation attacks against web application. Web application attacks gives chance to the attacker to get unrestricted access to data base and web servers. In this approach we have proposed a two step approach to detect input validation attacks against web applications. By using our approach we can prevent input validation attacks against web applications very efficiently. In the first step we have used a honey pot system to find any malicious data is present or not. In the second step we have used efficient intrusion mechanism to identify the attacks that was not identified in the first step. In this we used an efficient Hirschberg algorithm this is a divide and conquer approach to find attacks against web applications. This system analyzes malicious code and immediately generates an alert to protect web applications from the attacker. By using this technique we can reduce the analysis time and false positive rate.

Mitigation of Web Based attacks using Mobile Agents in client side

Web applications are becoming the dominant way to provide access to on-line services such as e-commerce & e- banking. Attackers have found new type of attacks to exploit vulnerabilities in these web applications. Among these attacks reflected web parameter attacks have received much attention in the recent scientific literature. Efficient mechanism such as Input validation is an addition overburden scenario for executing a secure transaction in a server side. This paper presents a new, highly automated approach that prevents web parameter attacks using mobile agents in the client side. Our Proposed system has to extract keywords from the web application parameter in a client side and use the gene alignment approach to measure the identity between two parameter sequences in order to avoid web attacks. Hirschberg algorithm is an divide and conquer approach for measuring the relevance between two sequences and it has advantageous over other methods in order to reduce the time complexity O((nm)) and space complexity O(min (nm)). This system was able to stop all of the successful attacks and did not generate any false positives.

HMMConverter 1.0: a toolbox for hidden Markov models

Hidden Markov models (HMMs) and their variants are widely used in Bioinformatics applications that analyze and compare biological sequences. Designing a novel application requires the insight of a human expert to define the model's architecture. The implementation of prediction algorithms and algorithms to train the model's parameters, however, can be a time-consuming and error-prone task. We here present HMMConverter, a software package for setting up probabilistic HMMs, pair-HMMs as well as generalized HMMs and pair-HMMs. The user defines the model itself and the algorithms to be used via an XML file which is then directly translated into efficient C++ code. The software package provides linear-memory prediction algorithms, such as the Hirschberg algorithm, banding and the integration of prior probabilities and is the first to present computationally efficient linear-memory algorithms for automatic parameter training. Users of HMMConverter can thus set up complex applications with a minimum of effort and also perform parameter training and data analyses for large data sets.

FastLSA: A Fast, Linear-Space, Parallel and Sequential Algorithm for Sequence Alignment

Sequence alignment is a fundamental operation for homology search in bioinformatics. For two DNA or protein sequences of length m and n, full-matrix (FM), dynamic programming alignment algorithms such as Needleman-Wunsch and Smith-Waterman take O(m × n) time and use a possibly prohibitive O(m × n) space. Hirschberg's algorithm reduces the space requirements to O(min(m, n)), but requires approximately twice the number of operations required by the FM algorithms. The Fast Linear-Space Alignment (FastLSA) algorithm adapts to the amount of space available by trading space for operations. FastLSA can effectively adapt to use either linear or quadratic space, depending on the specific machine. Our experiments show that, in practice, due to memory caching effects, FastLSA is always as fast or faster than the Hirschberg and FM algorithms. To improve the performance of FastLSA further, we have parallelized it using a simple but effective form of wavefront parallelism. Our experimental results show that Parallel FastLSA exhibits good speedups, almost linear for eight processors or less, and also that the efficiency of Parallel FastLSA increases with the size of the sequences that are aligned. Consequently, parallel and sequential FastLSA can be flexibly and effectively used with high performance in situations where space and the number of parallel processors can vary greatly.

An Improved Search Algorithm for Optimal Multiple-Sequence Alignment

Multiple sequence alignment (MSA) is a ubiquitous problem in computational biology. Although it is NP-hard to find an optimal solution for an arbitrary number of sequences, due to the importance of this problem researchers are trying to push the limits of exact algorithms further. Since MSA can be cast as a classical path finding problem, it is attracting a growing number of AI researchers interested in heuristic search algorithms as a challenge with actual practical relevance. In this paper, we first review two previous, complementary lines of research. Based on Hirschberg's algorithm, Dynamic Programming needs O(kN^(k-1)) space to store both the search frontier and the nodes needed to reconstruct the solution path, for k sequences of length N. Best first search, on the other hand, has the advantage of bounding the search space that has to be explored using a heuristic. However, it is necessary to maintain all explored nodes up to the final solution in order to prevent the search from re-expanding them at higher cost. Earlier approaches to reduce the Closed list are either incompatible with pruning methods for the Open list, or must retain at least the boundary of the Closed list. In this article, we present an algorithm that attempts at combining the respective advantages; like A* it uses a heuristic for pruning the search space, but reduces both the maximum Open and Closed size to O(kN^(k-1)), as in Dynamic Programming. The underlying idea is to conduct a series of searches with successively increasing upper bounds, but using the DP ordering as the key for the Open priority queue. With a suitable choice of thresholds, in practice, a running time below four times that of A* can be expected. In our experiments we show that our algorithm outperforms one of the currently most successful algorithms for optimal multiple sequence alignments, Partial Expansion A*, both in time and memory. Moreover, we apply a refined heuristic based on optimal alignments not only of pairs of sequences, but of larger subsets. This idea is not new; however, to make it practically relevant we show that it is equally important to bound the heuristic computation appropriately, or the overhead can obliterate any possible gain. Furthermore, we discuss a number of improvements in time and space efficiency with regard to practical implementations. Our algorithm, used in conjunction with higher-dimensional heuristics, is able to calculate for the first time the optimal alignment for almost all of the problems in Reference 1 of the benchmark database BAliBASE.

HIRSCHBERG’S ALGORITHM FOR APPROXIMATE MATCHING

The Hirschberg algorithm was devised to solve the longest common subsequence problem. The paper discusses the way o f adopting the algorithm to solve the string matching problem in linear space to determine edit distancefor two strings and their alignment.

Using Hirschberg's algorithm to generate random alignments of strings

Hirschberg gave an alignment algorithm for the longest common subsequence problem that uses O( n 2) time and O( n) space for two strings of length ~ n. A simple modification of the algorithm can sample string alignments at random according to their probability distribution. This is useful for statistical estimation of evolutionary distances of a family of strings, e.g. DNA strings. The algorithm's time and space complexity are unchanged.