Tiglon enables accurate transcriptome assembly via integrating mappings of different aligners

Summary Full-length transcript reconstruction has a pivotal role in RNA-seq data analysis. In this research, we present a new genome-guided transcriptome assembly algorithm, namely Tiglon, which integrates multiple alignments of different mapping tools and builds the labeled splice graphs, followed by a label-based dynamic path-searching strategy to reconstruct the transcripts. We evaluate Tiglon on a simulated dataset and 12 real datasets under the Hisat2 and Star mappings. The results indicate that the integrating techniques of Tiglon exhibit great superiority over the state-of-the-art assemblers, including StringTie2 and Scallop, depending on Hisat2 alignments, Star alignments, or the merged alignments of both. Especially, Tiglon is significantly powerful in recovering lowly expressed transcripts.

INTRODUCTION RNA-seq, as a powerful technology for transcriptome analysis, is extensively used worldwide. Especially during the past five years, this technology has transitioned from research to clinical use (Phillips et al., 2020), which sheds light on the study of complex diseases related to abnormal splicing events or differential expression levels such as cancers. Moreover, it provides the opportunity to view the complexity of eukaryotic transcriptomes, identify the expressed transcripts, and quantify their expression abundance precisely at a whole transcriptome level (Marguerat and Bä hler, 2010;Ozsolak and Milos, 2010;Wang et al., 2009;Wilhelm and Landry, 2009). One of the most critical steps for RNA-seq data analysis is accurately assembling the tremendous amount of sequencing reads into full-length transcripts, which is quite a computationally challenging task.
To the best of our knowledge, none of the current assemblers is specifically designed for integrating alignments generated by different mapping tools, which is of great significance practically. As shown in the IGV snapshot (Figure 1), the annotated transcript ''XR_929,880.3'' in NCBI RefSeq from human reference genome GRCh38 is captured by the RNA-seq sample SRA: SRR307911 (NCBI SRA accession code). In the region, we can see that both the Hisat2 and Star (two of the best current aligners) alignments cover the whole exons of this transcript, but neither of them covers the entire junctions. Consequently, assemblers depending on only one aligner cannot recover this transcript, which is actually reconstructed by the proposed Tiglon algorithm. It suggests that integrating alignments of different aligners would be a helpful and meaningful strategy for transcriptome assembly.
In this research, we introduce Tiglon, an elaborately designed genome-guided transcriptome assembly approach that integrates mappings produced by different aligners. Taking advantage of different alignments, Tiglon builds a new graph model, namely labeled splice graph, in which each node corresponds to an exon, and each edge corresponds to a junction, and Tiglon further labels the edges (junctions) with 1 and 2, where label 2 indicates that they are captured by all the employed aligners and label 1 otherwise. In addition, label 2 further categorizes into 2+ and 2-, where 2 + means that the captured reads of different aligners are exactly the same and 2-otherwise. Next, based on the labeled splice graph, Tiglon employs a newly developed labeled-based dynamic path extension program to recover the expressed transcripts accurately.
Tested on a simulated dataset and 12 real datasets (8 from Homo sapiens samples and 4 from Mus musculus samples), the integrating techniques of Tiglon demonstrate significantly superior over the best current approaches, including StringTie2 and Scallop that depends on Hisat2 alignments, Star alignments, or the merged alignments of the two ones mentioned above, and StringTie2-Merge (the -merge mode of StringTie2). For instance, on the eight tested H. sapiens datasets, Tiglon averagely reconstructed 9.51% more correct transcripts than StringTie2-Merge, 11.25%-13.68% more than StringTie2 and Scallop depending on the merged alignments, and 19.82%-25.61% more than StringTie2 and Scallop depending on Hisat2 or Star alignments. More critically, Tiglon exhibits significant superiority over others in recovering lowly expressed transcripts. On the eight H. sapiens samples, Tiglon correctly recovered 22.57%-53.48% Figure 1. An IGV snapshot shows that the reference transcript named ''XR_929,880.3'' of human genome GRCh38 is covered by reads from RNAseq sample SRA: SRR307911 The exons of this transcript are all captured by both Hisat2 and Star mappings, while its first junction is not captured by Star mapping, and its fifth junction is not captured by Hisat2 mapping. Depending on only one aligner, StringTie2 and Scallop cannot recover this transcript, while Tiglon recovers it by integrating both alignments.

RESULTS
Tiglon is a transcriptome assembly approach that takes advantage of multiple alignments generated by different mapping tools. In this study, we first focused on the performance comparison between Tiglon and two of the best and representative assemblers StringTie2 and Scallop, depending on the Hisat2 alignments, Star alignments, and the merged alignments of both. Additionally, we evaluated the performance of Tiglon that was run with multiple aligners or with only one aligner, and we also compared Tiglon with two of our previous algorithms TransBorrow and iPAC. Based on the comparing results, the integrating strategy of Tiglon exhibited superior performance on both simulated and real datasets. The common comparison criteria used in this study were that a reference transcript is considered to be correctly identified if and only if its intron chain is exactly matched with an assembled transcript, and this matched assembled transcript is regarded as correctly assembled. And, we used the Cuffcompare tool in the Cufflinks package (Trapnell et al., 2010) to detect the correctly assembled transcripts. The accuracy of an assembler is measured by the number of correctly assembled transcripts and precision, the percentage of correctly assembled transcripts out of all the predicted ones. The versions of reference genome and transcriptome for the H. sapiens and M. musculus samples used in this research are GRCh38/hg38 and GRCm38/mm10, respectively, which were downloaded from the UCSC Genome Browser.

Performance evaluation on simulated dataset
In this study, we used RNA-seq data simulator RSEM (Li and Dewey, 2011) to generate a simulated dataset that contained 52 million 100-bp length paired-end reads. The parameters of the simulation model were learned from the real human RNA-seq dataset with the NCBI SRA accession code of SRR7536920. Next, we mapped the simulated reads to the reference genome by using Hisat2 and Star. We subsequently used the samtools merge (Li et al., 2009) to generate the merged alignments based on the mapping results of the two aforementioned aligners. We ran Tiglon with alignments generated by both aligners as its input, while ran StringTie2 and Scallop with the alignments of each aligner and the merged alignments as their input, denoted as StringTie2+Hisat2, StringTie2+Star, StringTie2+MergedAlignments, Scallop + Hisat2, Scallop + Star, and Scallop + MergedAlignments. In addition, we ran StringTie2 in the mode -merge with the assemblies produced by StringTie2+Hisat2 and StringTie2+Star as its input to generate a unified set of transcripts, denoted as StringTie2-Merge.
First, we evaluated the performance of each assembler by precision and the number of correctly assembled transcripts. Testing results on the simulated dataset showed that Tiglon performed the best, which correctly reconstructed much more transcripts, while kept the highest precision. Concretely, the correctly assembled transcripts of Besides, we further calculated the F-score, a harmonic mean of recall and precision (calculated as 2*precision*recall/(precision + recall)) to evaluate the overall performance of each assembler, where the recall means the fraction of correctly identified reference transcripts in the ground truth. On the simulated dataset, Tiglon obtained an F-score of 0.480, a significant increase over  Figure 2B and Table S2).

OPEN ACCESS
iScience 25, 104067, April 15, 2022 3 iScience Article Generally speaking, it is more difficult to reconstruct transcripts with relatively low expressions, while lowly expressed ones may play important roles in organisms. We then evaluated the ability of assemblers in recovering transcripts with different expression levels. As did by Shao et al. in their evaluation of Scallop (Shao and Kingsford, 2017), we first sorted the expressed transcripts according to their expression abundances. Then, all the expressed transcripts were equally divided into three parts, which corresponded to low, middle, and high expressed ones. Finally, we computed the number of correctly identified transcripts in each part for each assembler. The results revealed that Tiglon consistently outperformed all the others in recovering transcripts of different expression levels ( Figure 2C and Table S15). Particularly for the lowly expressed ones, Tiglon correctly recovered 30.11% more than StringTie2-Merge, 19.08% more than StringTie2+MergedAlignments, 58.06% more than Scallop + MergedAlignments, and 40%-108% more than StringTie2 and Scallop depending on different aligners.
Based on the above comparison, it is concluded that by integrating alignments produced by Hisat2 and Star, Tiglon achieved the best performance among the tested assemblers. Especially, Tiglon reconstructed significantly more expressed transcripts than the others.

Performance evaluation on the real datasets
Because the expressed transcripts and their expression abundances are precisely known for the simulated dataset, tests on the simulated data are persuasive. However, simulation cannot capture the entire features of real biological datasets, so evaluation on real datasets is of great significance to further verify the assembling performance in real applications. Different from the simulated dataset, the ground truth of real datasets is difficult to know. Nonetheless, it is generally safe to assume that an assembler is more accurate if it recovers more known annotated transcripts (Kovaka et al., 2019). In this study, all the transcripts (NCBI RefSeq in GTF format) of the species H. sapiens and M. musculus downloaded from the UCSC Genome Browser were set as the ground truth. And, eight H. sapiens RNA-seq samples H1-H8 and four M. musculus RNA-seq samples M1-M4 were collected to evaluate the performance of the assemblers. All these datasets were downloaded from NCBI Sequence Read Archive (SRA); the accession codes for the H. sapiens samples were SRA: SRR307911, SRA: SRR387662, SRA: SRR10517380, SRA: ERR2403203, SRA: SRR307903, SRA: SRR315323, SRA: SRR315334, and SRA: SRR7536920, and for the M. musculus samples were SRA: DRR205674, SRA: DRR205677, SRA: ERR3320855, and SRA: ERR3320871. The detailed description of these datasets can be found in Table S1. We then evaluated the assemblers on the 12 real datasets in terms of the same criteria as we did on the simulated dataset. The results exhibited that Tiglon consistently achieved the best performance on all the 12 real datasets.

sapiens samples
We first mapped the eight H. sapiens RNA-seq samples to the reference genome by using Hisat2 and Star, respectively, followed by generating the merged alignments for each sample, and we subsequently ran the assemblers. The results showed that Tiglon reached consistently and significantly a higher number of correctly assembled transcripts and precision than all the other assemblers on all the tested datasets ( Figure 3).   On the whole, averaged on the eight tested datasets, Tiglon reconstructed 9.51% more correct transcripts than StringTie2-Merge, 11.25% more than StringTie2+MergedAlignments, 13.68% more than Scallop + MergedAlignments, 25.32% more than StringTie2+Hisat2, 21.21% more than StringTie2+Star, 25.61% more than Scallop + Hisat2, and 19.82% more than Scallop + Star ( Figure 3A and Tables S3-S10).
The high number of correct transcripts assembled by Tiglon was not at the cost of its precision. In terms of precision, Tiglon still kept the highest on all the tested samples.  Figure 3A and Tables S3-S10).
Furthermore, we calculated the F-score for each assembler, and Tiglon remained in its best performance. Averaged on the eight samples, the F-score of Tiglon reached 0.1701, which was about 10.67%-28.08% higher than the other approaches ( Figure 3B and Tables S3-S10).
After that, we evaluated the ability of the assemblers in reconstructing transcripts with different expression levels. Although we cannot know the expression abundance for the ground truth, we used the well-known abundance estimator Kallisto (Bray et al., 2016) to quantify the eight RNA-seq samples. Based on the estimated abundance, we classified transcripts into three parts corresponding to low, middle, and high expression levels as we did on the simulated dataset. Comparing among these assemblers, Tiglon consistently achieved the highest number of correctly assembled transcripts on different expression levels upon all the tested samples ( Figure 3C and Tables S16-S23). What's more, Tiglon exhibited a significant superiority over all the others in producing transcripts with low expression levels. On the eight samples, Tiglon correctly recovered 22.57%-53.48% more lowly expressed transcripts than StirngTie2-Merge, 29.73%-62.48% more than StringTie2+MergedAlignments, 40.71%-89.05% more than Scallop + MergedAlignments, 67.65%-135.38% more than StringTie2+Hisat2, 51.93%-87.11% more than StringTie2+Star, 68.20%-161.18% more than Scallop + Hisat2, and 59.28%-116.55% more than Scallop + Star.

Performance evaluation on the M. musculus samples
We then evaluated the performance of Tiglon on the four M. musculus samples. We first mapped the four M. musculus RNA-seq samples to the reference genome and generated the merged alignments, and then ran the assemblers depending on the alignments. As expected, Tiglon actually demonstrated the best performance ( Figure 4).  Figure 4A and Tables S11-S14).

Performance evaluation on additional samples
With so many public RNA-seq samples available, in addition to the above evaluation, we further ran the assemblers on additional 38 real RNA-seq samples, with 28 from the species of H. sapiens and 10 from the M. musculus (Table S1 record the accession code and description of these samples). On all these additional tests, Tiglon consistently exhibited the best performance with significant improvements in both the number of correctly assembled transcripts and precision over all the other approaches ( Figures S1-S4).

Performance comparisons between running tiglon with multiple aligners and with only one aligner
Tiglon is specifically designed for integrating multiple alignments to assemble full-length transcripts, where the alignments are generated by different mapping tools. To show the advantages of Tiglon's integrating technics (here denoted as Tiglon + Hisat2&Star), we further ran Tiglon with the alignments generated by only one aligner (Hisat2 or Star) as its input on the eight H. sapiens samples H1-H8, and four M. musculus samples M1-M4, denoted as Tiglon + Hisat2 and Tiglon + Star. We compared Tilgon + Hi-sat2&Star with Tiglon + Hisat2 and Tiglon + Star, and the results demonstrated that Tiglon + Hisat2&Star performed significantly better no matter in terms of precision or the number of correctly assembled transcripts. Averaged on the eight H. sapiens samples, Tiglon + Hisat2&Star showed an improvement of 6.47% iScience Article and 6.91% on precision, and 16.11% and 13.98% on the number of correct transcripts over Tiglon + Hisat2 and Tiglon + Star. And, on the four M. musculus samples, the improvements were 9.19% and 7.26%, and 12.17% and 10.05%, respectively (Figures S5-S6 and Tables S3-S14).

Comparing tiglon with our previous algorithms TransBorrow and iPAC
We then compared Tiglon with our previous algorithms, TransBorrow (Yu et al., 2020b) and iPAC (Yu et al., 2020a), both were single aligner-based assemblers, where TransBorrow that employed a borrowing strategy was run by taking the assemblies of StringTie2 and Scallop as its input, and iPAC was run with its default setting. We evaluated the performance on the eight H. sapiens samples H1-H8, and the four M. musculus samples M1-M4 under Hisat2 and Star alignments. It is worth mentioning that TransBorrow and iPAC cannot be run with the merged alignments produced by samtools merge. The comparing results exhibited that the proposed multiple aligner-based Tiglon algorithm outperformed both TransBorrow and iPAC significantly. For instance, averaged on the eight H. sapiens samples, Tiglon correctly recovered 12.2% and 8.5% more transcripts than TransBorrow + Hisat2 and TransBorrow + Star, and 16.1% and 14.0% more than iPAC + Hisat2 and iPAC + Star, while in terms of precision, Tiglon averagely showed an improvement of 4.02%-4.26% over TransBorrow and 6.47%-6.91% over iPAC depending on Hisat2 or Star alignments (see Figures S7, S8 and Tables S3-S14 for details).

Additional tests
It is worth mentioning that, in this research, we used Hisat2 and Star to produce the alignments for the RNAseq samples, where Star was run with its default settings, while Hisat2 was run with the option -dta (in the Hisat2 manual, it means ''reports alignments tailored for transcript assemblers''). Here, we further used the default settings (without the option -dta) of Hisat2 to generate the alignments. Based on the new produced Hisat2 default alignments and the aforementioned Star alignments, we made the test on the samples H1-H8 and M1-M4 once again, and the testing results exhibited a similar performance trend where Tiglon consistently kept the superior performance ( Figure S7).

Comparison of consumptions of computing resources
All the assemblers were run on the same server with 768 GB of memory and a 32-core CPU. On all the tested datasets, Tiglon ran a little slower than StringTie2 and Scallop, and it costed more memory than StringTie2, which was almost the same as Scallop. For example, on the first dataset H1, which contains 41 million paired-end reads, the running time of StringTie2 was 18 and 17 min based on Hisat2 and Star, respectively, 19 and 19 min for Scallop, and 46 min for Tiglon that ran with the alignments produced by both aligners in parallel. For memory usage, StringTie2 costed the least memory of no more than 1 GB. In contrast, the two assemblers Scallop and Tiglon exhibited a similar trend, with the maximum memory usage of 5-9 GB for Scallop and approximately 8 GB for Tiglon. Overall, Tiglon is not the most economical in running time and memory usage; even so, it is quite acceptable for practical use.

DISCUSSION
We present Tiglon, a new genome-guided assembler that integrates multiple alignments of different mapping tools to reconstruct transcripts. We mainly focused on the performance comparison between the proposed Tiglon and two of the extremely popular and extensively used assemblers StringTie2 and Scallop, depending on the alignments of Hisat2, Star, and the merged alignments of both. Based on the test results, Tiglon demonstrated a significant superiority in performance on both simulated and real biological datasets. Its advantages may be attributed to 1) integrating alignments of different aligners and building the labeled splice graph capture more splicing junctions than the traditional approaches, which base on only one aligner 2) extracting much more reliable paired paths depending on the labeled splice graph, and 3) the newly developed labeled-based dynamic path-searching techniques for extracting all the transcript-representing paths over the labeled splice graphs. These unique ingredients make the Tiglon algorithm not only highly sensitive but also remarkably precise.
Moreover, we compared Tiglon with two of our previous algorithms TransBorrow and iPAC, where iPAC utilized the phasing graph model, and TransBorrow employed a borrowing strategy (make use of the assembly results of other algorithms). These two assemblers are designed from different angles to generate the assemblies. However, both are not compatible with the merged alignments produced by different aligners. The proposed Tiglon algorithm, which is designed for integrating multiple alignments, exhibits iScience Article better performance. That is to say, taking multiple alignments into consideration would be a helpful strategy for transcriptome assembly. We hope it would open up new ideas for the researchers to develop better algorithms. From our perspectives, a combination of the proposed integrating strategy and the borrowing strategy that used in the TransBorrow algorithm would be an interesting attempt to improve the assembly accuracy. We will definitely explore this in our future work.
Although the current version of Tiglon exhibits significant advantages, there is still room for further improvements in the future. For instance, the current version is not compatible with long-read RNA-seq datasets (e.g., Pacific Biosciences [PacBio] or Oxford Nanopore Technologies [ONT]). In the future version, we will attempt to solve the problem.
To the best of our knowledge, Tiglon is the first genome-guided transcriptome assembler that is specifically designed to integrate alignments of different mapping tools to build the labeled splice graph and to extract more reliable paired paths. Tiglon employs a dynamic programming algorithm to recover the transcripts by making strategic use of the label information. The software has been developed to be user-friendly. It is expected to play a crucial role in discoveries of transcriptome studies using RNA-seq, especially in complicated human diseases related to abnormal splicing events and expression levels, such as cancers.

Limitations of the study
We introduce a new tool designed to deliver better performance in transcriptome assembly. The current version of Tiglon does not have an option for annotation-guided assemblies, i.e., where the known transcript annotations are used to guide the assembly procedure. Such annotation-guided assembly is supposed to achieve higher accuracy. We intend in our future work to focus not only on the usage of the sequence alignment but also on the usage of other information, such as the known annotations, and even the assembly results of other tools.

STAR+METHODS
Detailed methods are provided in the online version of this paper and include the following:

ACKNOWLEDGMENTS
This work was supported by the National Natural Science Foundation of China with codes 11931008, 12101368, and 61771009, and the National Key R&D Program of China with code 2020YFA0712400. The funders had no role in study design, data collection and analysis, decision to publish, or preparation of the manuscript. Yu, T., Mu, Z., Fang, Z., Liu, X., Gao, X., and Liu, J.

Lead contact
Further information and requests for resources should be directed to and will be fulfilled by the lead contact, Ting Yu (yutingsdu@163.com).

Materials availability
No unique reagents were generated in this study.  Table S1. Besides, the running command for each tool can be found in a shell script from https://sourceforge.net/projects/tiglon/files.

Data and code availability
Any additional information required to reanalyze the data reported in this article is available upon request from the primary contact.

METHOD DETAILS
By combining multiple alignments of different mapping tools, Tiglon constructs a new graph model, namely the labeled splice graph, which integrates the paired-end and sequence depth information generated by different alignments effectively. Based on the labeled splice graph, Tiglon extracts more reliable paired-end paths, and each paired-end path is given a label as well, followed by a label-based dynamic programming path searching strategy to reconstruct the transcripts (See Figure S10 for the flowchart of Tiglon algorithm).

Building labeled splice graphs
To make full use of the alignments produced by different mapping tools, we first build the traditional splice graph based on each aligner and then merging them into the so-called the labeled splice graph.

Building splice graphs depending on alignments of each aligner in parallel
First, based on alignments of RNA-seq reads to the reference genome, we cluster the reads into different gene loci. The exon-exon splicing junctions are derived from those junction reads. Then for each gene locus, we build the traditional splice graph G = (V, E), in which each node v corresponds to an exon and each edge e corresponds to a splicing junction between two exons. Moreover, the edges and nodes are weighted by the number of reads supporting them. It is worth mentioning that we heuristically remove relatively low-weight edges or nodes that may be caused by sequencing errors or unreasonably aligns After the splice graph is built, the sequence depth information will be projected onto the nodes and edges of the splice graph as their weights. Generally, the weight of each node is defined as the average coverage of the aligned reads to it, and the weight of every edge is defined as the number of spliced reads that span it. Note that if a read is aligned to multiple sites, suppose N, the contribution of this read is recorded as 1/N.
However, there may be quite a number of spurious splicing junctions in the splice graphs caused by sequencing errors or mapping errors. We heuristically remove edges and nodes with relatively low weight via the following criteria. 1) An edge with its weight less than 1 (noting that if a read is aligned to N sites, the contribution of this read is 1/N) then it may correspond to a sequencing or mapping error. 2) If there is a node with several out-(or in-) edges, such that one of them has a much smaller weight than the total out-(or in-) weights (less than 0.1), then it probably represents a spurious splicing junction. 3) If the weight of an out-(or in-) edge is less than 3% of the total in-(or out-) edges, then it is considered as a spurious splicing junction. 4) If the weight of an edge is less than 2% of the average edge weight of the corresponding splice graph, then we will also remove this edge. 5) If the weight of a single node (a node that is without incoming edges and outgoing edges) is less than 10, the node is regarded as a false positive.
In theory, most splicing events in the expressed transcripts can be captured by the edges in the splice graphs, and the sequencing depth information is appropriately used for the graph as the node and edge weights. However, based on the alignments generated by only one aligner, a large number of spurious (or missing) nodes and splicing junctions in the splice graphs may be caused by the mapping errors (As an example in Figure 1, neither Hisat2 nor Star mappings captured the whole junctions of an annotated transcript). Moreover, a large number of paired paths (paths in the graph supported by the paired-end reads) extracted from the traditional splice graph are not reliable. Thus, it is knotty to accurately recover all the expressed transcripts based on the inaccurate splice graph generated using only one aligner. However, via fully integrating the traditional splice graphs produced by different aligners, more accurate splice graphs can be constructed, named the labeled splice graphs.

OPEN ACCESS
iScience 25, 104067, April 15, 2022 13 iScience Article Merging splice graphs of each aligner to generate the labeled splice graph Suppose that we get N aligners to generate the alignments, and for each gene locus, we denote the splice graph generated based on the aligner i ði % NÞ as G i = (E i , V i ), and for each edge e i˛Ei , we denote the set of reads that support e i as R ei . The labeled splice graph G L = (E L ,V L ) is generated by merging the splice graphs G i for i˛½1; N, in which the nodes and edges represent all the nodes and edges appearing in G i (i˛½1; N). Then we label G L in the following ways, for each edge e in G L , if d j˛½1; N such that e ; E j , then we label e with 1; otherwise, we label it with 2. In addition, for the edge e˛E L with label 2, if there exist i and j (i; j˛½1; N; and i s j) such that R ei s R ej , we further label it with 2-, otherwise we label it with 2+. Afterwards, the weights of the edges of the labeled splice graph are assigned as the average weights of the edges appearing in each G i for i % N.

Extracting labeled paired paths
To make full use of the paired-end information for guiding more accurate transcript assembly, we extract reliable labeled paired paths from each labeled graph.
First, for each gene locus, we generate a set of paired paths for each aligner i, denoted as PP i , which is achieved by the following ways. For each paired-end read r 1 and r 2 , based on the mappings of aligner i, if r 1 spans a path p 1 = n j1 /n j2 / . /n jk , r 2 spans a path p 2 = n j'1 /n j'2 / . /n j'q in graph G L , and p 1 and p 2 share a compatible sub-path p in = n m1 /n m2 / . /n ms satisfying k + q -s R 3, then the paired path p is generated by connecting the two paths p 1 and p 2 via the shared compatible path p in , where the compatible sub-path means the same sub-path at the right (left) terminal of p 1 and the left (right) terminal of p 2 , and the shared sub-path contains at least one edge of the labeled splice graph (see Figure S11 for an example). After all the paired-end reads mapped to G L are processed, we obtain a set PP i of all paired paths depending on the aligner i. And it is worth mentioning that different paired-end reads may generate the same paired path. Therefore, for each path p˛PP i , we denote R pi as the set of paired-end reads to generate p, and the number of paired-end reads that generate each paired path is regarded as the coverage of the path, denoted as cov(p).
After generating the paired path set PP i along with paired-end reads set R pi of each p˛PP i for each aligner i, we set PP L = U i˛½1; N PP i be the paired path of the labeled splice graph. Then we label each paired path in PP L as how we label each edge e˛E L which is described in Merging splice graphs of each aligner to generate the labeled splice graph.

Employing a new label-based dynamic programming path extraction algorithm
Theoretically, the expressed transcripts of a gene correspond to a path cover in the labeled splice graph. Moreover, each labeled paired path corresponds to a segment of an expressed transcript and should be covered by at least one predicted transcript. To achieve this goal, we strategically use the label information and the reliable labeled paired paths in the labeled splice graph and employ a new labeled-based dynamic programming algorithm that is similar to our previous study (Yu et al., 2021) to generate the transcript-representing path cover over each labeled graph. In detail, we recover the expressed transcripts by the following steps.
Step1. Choosing a seed and generate a subgraph from the seed A seed is an edge or a paired path in the labeled splice graph that can further grow into a full-length transcript-representing path. Choose an unused paired path of label 2+ with the largest weight as the seed. If such kinds of paired paths do not exist or they have been all included in the assembled transcripts, the seed will be chosen in the following order: paired paths with label 2-, edges with label 2+, edges with label 2-, paired paths with label 1 or edges with label 1. Paired paths or edges with label 2 mean that they are captured by multiple aligners. That is, they are more likely to be true positives, and such seeds will grow into expressed full-length transcripts with higher probability.
Suppose the chosen seed be S = v k /v k+1 / . /v l for a paired path or S = v k /v l for an edge. We extend it to all the right (left) neighbors of node v k (v l ) and keep extending until all the neighbors encounter a node without out-(in-) edges, then a subgraph G S of G L is generated from the chosen seed.

OPEN ACCESS
iScience Article