HPC-T-Annotator: an HPC tool for de novo transcriptome assembly annotation

Abstract

Background

The availability of transcriptomic data for species without a reference genome enables the construction of de novo transcriptome assemblies as alternative reference resources from RNA-Seq data. A transcriptome provides direct information about a species’ protein-coding genes under specific experimental conditions. The de novo assembly process produces a unigenes file in FASTA format, subsequently targeted for the annotation. Homology-based annotation, a method to infer the function of sequences by estimating similarity with other sequences in a reference database, is a computationally demanding procedure.

Results

To mitigate the computational burden, we introduce HPC-T-Annotator, a tool for de novo transcriptome homology annotation on high performance computing (HPC) infrastructures, designed for straightforward configuration via a Web interface. Once the configuration data are given, the entire parallel computing software for annotation is automatically generated and can be launched on a supercomputer using a simple command line. The output data can then be easily viewed using post-processing utilities in the form of Python notebooks integrated in the proposed software.

Conclusions

HPC-T-Annotator expedites homology-based annotation in de novo transcriptome assemblies. Its efficient parallelization strategy on HPC infrastructures significantly reduces computational load and execution times, enabling large-scale transcriptome analysis and comparison projects, while its intuitive graphical interface extends accessibility to users without IT skills.

Background

Ribonucleic acids (RNA), a type of biomolecules found in cells and organisms, are the real-world expression of the genome being transcribed (or expressed), producing a so-called transcriptome. RNAs play a crucial part in gene expression, the process connecting the genotype to the phenotype of an organism: RNAs act like couriers carrying the genetic instructions stored in DNA (genotype) to guide the creation of proteins and other functional molecules defining an organism’s physical traits (phenotype) [1, 2].

Next-Generation Sequencing (NGS) technologies, among which RNA sequencing (RNA-Seq), have given researchers access to the intricate architecture and dynamic activity of the transcriptome. From simple organisms like yeast to more complex ones like humans, this technique offers unparalleled levels of sensitivity and precision in mapping the transcriptome’s dynamism and complexity [3].

de novo transcriptome assembly is the process of reconstructing a transcriptome from short, fragmented RNA sequences obtained through massive sequencing technologies [4,5,6,7,8,9,10,11,12]. This is an important issue in transcriptomics as sequencing technologies only produce RNA sequences of limited length, requiring the reconstruction of the whole transcriptome from these tiny fragments [13,14,15,16,17,18,19]. Several assembly algorithms (e.g., Trinity [20], rnaSPAdes [21], Oasis [22]) can be used to reconstruct the complete transcriptome. Once the assembly is completed, the process of transcriptome annotation is an important computational phase to understand the functions of the genes and other elements in a transcriptome, and how they contribute to the overall biology of an organism [5, 23]. Transcriptome annotation allows us to understand which genes are being expressed in a particular cell or tissue at a given time, and how the expression of these genes contributes to the overall biology of the cell or tissue.

Two main types of annotation are used:

• Homology-based annotation identifies genes or elements similar to known ones in other organisms.

• Functional annotation predicts a gene’s or element’s function based on its sequence and other features, without knowledge of genes or elements in other organisms.

Both types are important for understanding the biology of a transcriptome and identifying genes or elements of biological potential, such as conservation of genomics biodiversity, or biomedical interest. Homology-based annotation concerns the mapping of nucleotide or protein sequences in large protein databases. This typically involves the NR [24], Swiss-Prot [25], or TrEMBL [26] databases. These databases contain protein sequences from different organisms, both model and non-model. They can be used to identify homologous genes or elements in the transcriptome that is being annotated.

The homology-based annotation process is computationally demanding and resource-demanding, especially in the presence of very large transcriptomes. Sequence annotations are usually computed using alignment algorithms like BLAST [27] or DIAMOND [28], aligning protein or nucleotide sequences against protein databases. These tools are engineered for handling large-scale sequencing data efficiently and effectively. Once the sequence alignments are obtained from the analysis, homologous proteins are identified. Matches with a high level of similarity allow researchers to attribute a function to query sequences, based on knowledge about homologous proteins in other organisms. Although DIAMOND can be up to 10,000 times faster than the gold standard, BLAST, annotating a medium-to-large transcriptome can still require several days of computation on a single multi-core computing node.

In recent decades, many bioinformatics domains dealing with big data analysis have turned to High Performance Computing (HPC) tools: from HPC services for bioinformatics [29, 30], to genomics [31,32,33], transcriptomics [34, 35], metagenomics [36, 37], as well as in structural bioinformatics [38,39,40,41,42]. In particular, concerning sequence alignment, several optimisation experiments for BLAST and DIAMOND were conducted. The optimised BLAST implementations were designed for either GPU [43, 44] or CPU clusters [45, 46]. An optimised version of DIAMOND is available for HPC clusters [47], while another version improved the original algorithm by using efficient compression of the indices [48]. All these versions, optimised for HPC clusters, can be challenging to use (installation, configuration, and launch) for users without HPC expertise.

To overcome the primary computational bottleneck in de novo transcriptome annotation-the alignment of large sequences against a protein reference database-and to provide a user-friendly alignment software in the HPC environment, we introduce HPC-T-Annotator, a software suite which optimizes HPC machine resources efficiently and effectively, adopting a novel load-balancing technique, in order to derive homology-based on annotation of de novo transcriptomes from BLAST and DIAMOND. The tool parallelizes the alignment process, running multiple tasks simultaneously across different processors or computing nodes, thus completing the alignment process in less time than would be possible using a single processor or computing node.

While its primary purpose is to map de novo transcriptomes against specific protein databases, HPC-T-Annotator can also be used to map predicted Open Reading Frames (ORFs), in terms of coding sequences or proteins (peptide sequences), as well as differentially expressed genes, against the aforementioned databases.

The rest of the paper proceeds as follows. In Sect. Implementation, we are concerned with implementation aspects, describing the algorithm and its operational mode, and focusing attention on the parallel execution process and the advantages it brings. In Sect. Results, an in-depth analysis of HPC-T-Annotator’s performance is conducted, comparing its operational mode with currently employed software with similar characteristics. Finally, in Sect. Discussion and conclusions, we provide general comments and discuss future developments.

The supplementary material gives details on the GUI and the integrated notebooks.

Implementation

The main usage schema of HPC-T-Annotator is shown in Fig. 1. The user starts by filling out a Web form with the project information. In response, the Web service generates a batch of customised scripts and compresses them in a .tar file. This archive must then be transferred to the HPC machine, where the user can launch the parallel annotation software from the command line. Experienced users may also choose to run HPC-T-Annotator without using the Web interface¹.

The Web interface (outlined in the supplementary material) is a critical component of the software, designed to enable straightforward usage of the application on an HPC cluster, even for users without advanced technical skills. This design aims to broaden the software’s appeal and increase the number of potential users.

Fig. 1

Workflow of HPC-T-Annotator: using the Web interface, the user (his/her actions are reported in italics) generates a .tar file containing all the scripts for launching and managing the parallel computational tasks on a HPC cluster. In addition, the user can directly upload a FASTA file on the cluster machine. After transferring the .tar file and the input FASTA file to the cluster, running start.sh activates the generated scripts. Once the final alignment output file in TSV format is created on the HPC cluster, the user downloads the TSV file locally and uses the Python notebooks in the HPC-T-annotator suite to process and visualise the results

Once the generated scripts are transferred on the HPC cluster and launched through the command line start.sh, a complex set of operations, described in detail in Sect. HPC-T-Annotator parallel workflow, is performed without any need for further user intervention. Specifically, they execute an optimised split of the sequence file to be annotated. Each partial file, referred to as a chunk file, is then aligned against the database through a master/worker² model for parallel computing. Each worker process aligns the small fraction of the total sequences included in the chunk file. The results are then combined by the master process into a unified output in TSV format³. After the final alignment output file in TSV format is generated on the HPC cluster, the user must download the TSV file locally to post-process the alignment results. The user can then utilize the Python notebooks provided by the HPC-T-annotator suite⁴. In particular, they include:

• AnnoDegsReport: a multi-database annotation summary that consolidates the annotation results of a specific transcriptome obtained by running alignment software (DIAMOND and BLAST) against various sequence databases.

• AnnoRate: to compare database performances in terms of hit percentages for each sequence file and for each reference database.

• AnnoViz: which takes as input the output file generated by annotation software (BLAST or DIAMOND) and creates graphs providing an interpretation of the annotation and alignment results.

• MultiVenn: useful for comparing annotation results across different databases.

HPC-T-Annotator parallel workflow

The HPC-T-Annotator software workflow (see Fig. 2) can be described as follows:

• 1. preparation of input files and directives for workers processes;

• 2. activation of the workers to operate concurrently, and monitoring of their status;

• 3. aggregation of the partial outputs from individual workers into a single output file.

The master process remains active for the whole duration of the parallel annotation process, ensuring that each task is run successfully to completion. At that point, it merges the partial alignment files, yielding a single comprehensive alignment file.

Fig. 2

Whole workflow of processing using the HPC-T-Annotator parallel engine, activated by launching the start.sh script on a multi-core server or a HPC cluster machine

The input file targeted for annotation is a de novo transcriptome, formatted in multi-FASTA, and ordered from the longest to the shortest sequence. A naïve splitting of the input file, which retains the same order of sequences, could result into partial files of greatly varying sizes (i.e., the initial files would be larger, with subsequent ones diminishing in size). To achieve a balanced input workload, we use a cyclic algorithm for the assignment of sequence IDs. As an initial step, the master process reads the user-supplied input file and records the IDs of n sequences into separate files (header_1.txt, $\dots$, header_k.txt), so that each header_i.txt file contains the headers corresponding to a portion of the sequences present in the original file.

In this way, each process will be assigned a specific set of sequences to align with. As scattering algorithm we use cyclic distribution, which consists of the cyclic assignment of sequences within the input file. Thus, with k the number of processes, process 0 will have assigned sequences such as sequence 0, sequence k, sequence 2k, etc. Similarly, process 1 will deal with sequence 1, sequence $k+1$, sequence $2k+1$, etc.

Algorithm 1 illustrates, in pseudocode, how the algorithm assigns to each process its pool of sequences from the original file. Each partial chunk (file) is aligned using BLAST or DIAMOND, producing a partial result in TSV format.

Algorithm 1

Cyclic distribution algorithm for n sequences on k processes

Control process and merging phase

The control process (a subprocess of the master) acts as an orchestrator and manages the entire second phase. Its primary role is to oversee the status of the processes executing the alignment phase on the partial sequence files. The control process regularly checks the status of each individual process to verify whether it has successfully completed its assigned task or if it is still ongoing. Once the control process confirms that all processes have completed their tasks, the master proceeds to initiate the merging operation; consolidating the alignment results from the partial files into a single comprehensive TSV file. If a worker process encountered an error during its execution, the inaccuracy is reported in the respective process error-file.

Results

We report here an assessment of HPC-T-Annotator by presenting performance data on some benchmarks and a comparison against other parallel alignment software.

Benchmarks

We conducted a benchmark study to assess how much a parallel application of homology annotation software, specifically DIAMOND and BLAST, would optimise performance. The study focused on the annotation of transcripts for the aforementioned four species, assessing efficiency and speed improvements achieved through parallel execution compared to traditional serial execution on transcriptomes with different sizes, in terms of number and length of sequences (contigs). Table 1 provides a reference to the input datasets. for the de novo transcriptomes of the selected species.

Table 1 Species names, links, and references for the de novo transcriptomes used in the benchmarks

In particular, we used data pertaining to one bacterium of the genus Altererythrobacter (Altererythrobacter sp.) and to three amphibians (Bombina pachypus, Salamandra salamandra, Hyla sarda). The bacterium’s transcriptome is an extremely small one (number of contigs: 220), whereas the amphibians’ transcriptomes are of medium (Bombina pachypus: 190,619 contigs) and large (Salamandra salamandra: 1,146,571 contigs, Hyla sarda: 1,295,741 contigs) size.

The temporal metric used in the following benchmarks is the elapsed time, which represents the execution time of HPC-T-Annotator from when the user starts the software to when they receive the result. The elapsed time includes the times for merging the partial files into the final output file. As for execution on the HPC cluster, HPC-T-Annotator is designed to assign each worker process and the master process to a compute node of the cluster. Table 2 presents the execution times for the species’ transcripts against the Swiss-Prot database using the DIAMOND alignment software, using 8 threads per worker process (even for serial execution) and with Diamond’s ultra-sensitive mode. Each species underwent two executions: one in serial mode using traditional alignment software and another in parallel mode using the alignment software with HPC-T-Annotator as parallelisation tool.

Table 2 Comparison between serial (1 selected process) and parallel run (200 selected processes) of HPC-T-Annotator executed on each of the four transcriptomes using DIAMOND as alignment software and Swiss-Prot as the query database, respectively

The data in Table 2 are rendered graphically in Fig. 3, showing the variations in serial execution time, and highlighting the markedly reduced execution time achieved by parallel application, showing a comprehensive view of the performance improvements. The results of the benchmark were remarkable, with the parallel execution approach showing substantial reductions in execution time compared to the traditional serial execution. This improvement in efficiency proved the potential of parallel application in accelerating the homology annotation process.

Fig. 3

Benchmark results of HPC-T-Annotator on predicted ORFs from various species de novo transcriptome, mapped on Swiss-Prot database. In this panel, the graph of the serial (one process) and the parallel (200 processes) times are represented

Also, we used the transcriptome of Hyla sarda (Tyrrhenian tree frog) as a reference and performed the alignment using the DIAMOND tool [28] against the Swiss-Prot database. We selected 1, 10, 100, 200, and 300 processes, respectively, with time and speed-up results shown in Table 3 and in the associated graph (Fig. 4).

Table 3 Performance Metrics of HPC-T-Annotator for annotating the Hyla sarda transcriptome using DIAMOND and Swiss-Prot Database, as the Number of Selected Processes Varies

One can notice that the overall execution time continues to decrease as the number of processes increases; this result is not surprising, as we expect such a trend up to the point where the number of processes is equal to the number of sequences (each process is assigned only one sequence). However, this is not always possible since the number of sequences may be very high, and it would not be feasible to have such a high number of nodes on physical machines.

Fig. 4

Benchmark results of HPC-T-Annotator on predicted ORFs from the Hyla sarda de novo transcriptome, mapped on Swiss-Prot database (data are plotted considering Table 3 )

Speed-up is here taken to represent the performance improvement achieved by executing code on a parallel computing system compared to a sequential execution on a single processor, thus quantifying the reduction in execution time when multiple processors or cores are utilised concurrently.

Parallel algorithm analysis studies the efficiency and effectiveness of algorithms designed for parallel computing architectures. Speed-up is a crucial aspect of parallel algorithm analysis because it provides a quantitative measure of the benefits obtained from parallelization. By comparing the execution times of parallel and sequential implementations, speed-up allows us to assess the efficiency of parallel algorithms and evaluate the scalability of the parallel computing system.

With $p$ the number of processes used and $T(p)$ the execution time for $p$ processes, the formula for speed-up is given by: $S(p) = \frac{T(1)}{T(p)}$, where the ideal speed-up should follow a linear trend of $S(n) = n$. Figure 4 presents the data from Table 3 in graphical form, on which several notable observations can be made.

In particular, a boost in performance resulted from leveraging the parallel execution capabilities of HPC-T-Annotator alongside DIAMOND, thus enabling faster and more efficient annotation of homologous sequences. The parallel application effectively utilised computational resources, resulting in optimal resource allocation and load balancing. These findings have profound implications for homology annotation, offering a promising solution for improving speed of large-scale sequence analysis.

• Single Process Execution (1 process): The elapsed time with serial version of the alignment software, with ultra-sensitive mode and 8 threads, is 101.71 minutes. The speed-up is 1 because there is no performance improvement.

• Parallel Execution (10 processes): With 10 processes, elapsed time drops sharply from 101.71 to 10.42 min. The speed-up is 9.76, indicating the potential improvement if the task could be perfectly parallelized.

• Further Parallelisation (100, 200, and 300 processes): As the number of processes increases, the elapsed time decrease, showcasing the benefit of parallel processing. The speed-up value also increase, which is promising. However, it is interesting to note that the increase in speed-up is not linear with the increase in the number of processes. This could be due to factors such as diminishing returns, general overhead, or resource limitations.

The determining factor for the slow increase in speed-up remains the execution of HPC-T-Annotator on clusters with high job competition and overload.

Regarding the accuracy analysis of HPC-T-annotator, we performed some tests, by launching on the same input query and database, both BLAST and DIAMOND in parallel and not parallel version. The results showed no significant differences among the various result files, thus confirming the same accuracy for the parallel version.

Comparison with other parallel alignment software

HPC-T-Annotator’s software is composed of three main parts, as described in Fig. 1, and in Fig. 2 for the details of parallel analysis: (1) the Web tool or configuration and generation of parallel software; (2) the (generated) parallel analysis software; and (3) the notebooks for post-processing analysis. To date, the scientific literature does not describe any software for sequence alignment on HPC as complete as ours (Web interface for configuring and generating the custom parallel software, easy launching parallel analysis on HPC platforms, and easy interpretation, with notebooks, of the alignment results). We compare available software with ours where there are similarities in at least one of the three main components.

In Table 4, we have reported the software architecture data and the usage of RAM, memory and I/O transfer, as well as the execution times of BLAST and DIAMOND when used in multithreading mode or launched on a single node. Additionally, we compared parallel versions of BLAST and DIAMOND with runs of HPC-T-annotator using the BLAST and DIAMOND functions, respectively.

Table 4 Comparison of various tools and their characteristics

In addition to these software applications, others exist which are equipped with an interface, but are not designed for HPC computation. Among the most interesting and recent ones is BlastGUI [50]. BlastGUI is a cross-platform, Python-based application that features a main interface allowing users to create databases, perform sequence filtering, and conduct sequence alignment through a graphical user interface. BlastGUI ‘s capabilities for operation visualization, automatic sequence filtering, and cross-platform use can significantly facilitate the analysis of biological data; however, BlastGUI does not have tools for analyzing data results and therefore does not help interpret the biological alignment data obtained.

Discussion and conclusions

In the landscape of transcriptomic data analysis, where handling large data sets is crucial for understanding the molecular mechanisms underlying complex biological phenomena, computation on High-Performance Computing (HPC) platforms can be essential. Optimized CPU usage and efficient workload distribution across cluster nodes are fundamental to enable thorough annotation within reasonable time frames. Swiftly annotating a de novo transcriptome, used as a reference resource, allows researchers to identify patterns of differential gene expression, regulatory elements, and evolutionary patterns, thus providing valuable insights for a wide range of biological studies, from bio-medicine to ecology and evolutionary biology.

In this context, HPC-T-Annotator emerges as an essential resource for big data analysis in transcriptomics, reducing execution times in large-scale de novo transcriptome annotation. Indeed, its ability to handle large data volumes and accelerate annotation tasks can significantly facilitate the advancement of biological research.

The capacity of HPC-T-Annotator to manage big data is implemented in all three main phases of the software(as shwon in Fig. 1 in Sect. 2), namely: generation of parallel computation software; deployment on the HPC cluster; and parsing of fundamental results using Python notebooks. Highlighting the tool’s ease of use even for researchers not specialized in IT, we report the following user-friendly usage features: (1) Researchers, even not not skilled in parallel computation can automatically generate and configure the HPC software they need by simply filling out a form. (2) The launch of the generated software modules only requires the execution of a simple command line⁵. (3) The generated TSV file, usually extremely large in size, can be quickly analyzed using the Python notebooks available online.

Although HPC-T-Annotator was primarily designed for transcriptome annotation, its parallelization framework and adaptable architecture have the potential for broader use in bioinformatics. The tool’s scalability and efficiency make it an ideal candidate for parallelising various computational tasks, such as metagenomic data annotation.

Further developments of HPC-T-Annotator are underway to improve the efficiency and speed of the annotation tasks. Currently, from the Web interface, it is only possible to configure the launch of the annotation of a single transcriptome against a single database. We plan to increase the potential for big data analysis by providing the ability to configure the annotation launch on different databases and several input transcriptomes simultaneously, simply by entering data in a single form.

Finally, the implementation of additional computational adaptations, such as extending software compatibility to clusters with schedulers other than SLURM and expand the suite of Python/Jupyter Notebooks for post-processing operations, will further amplify the accessibility and efficiency of the software, providing biologists and researchers with advanced tools for big data analysis.

Availability and requirements

• Project name: HPC-T-Annotator.

• Project home page:http://raganella.deb.unitus.it/HPC-T-Annotator/index.html.

• Operating system(s): Linux.

• Programming language: Bash, Python.

• Other requirements: Linux (Ubuntu 20.04 LTS, CentOS 7 or higher), SLURM 22.* or higher (optional).

• License: MIT.

• Any restrictions to use by non-academics: License needed.