PaperlayerView exact revision on arXiv

Source-linked AI summary

Nanopore Sequencing Technology and Tools for Genome Assembly: Computational Analysis of the Current State, Bottlenecks and Future Directions

Damla Senol Cali, Jeremie S. Kim, Saugata Ghose, Can Alkan, Onur Mutlu

arXiv:1711.08774v4q-bio.GN

TL;DR

Nanopore sequencing provides long reads and portability but has high error rates that challenge accurate genome assembly. The paper evaluates tools across the genome-assembly pipeline and their tradeoffs in accuracy, performance, memory usage, and scalability. Its observations support tool selection by researchers and practitioners and identify bottlenecks for future tool development.

  • Problem

    High nanopore sequencing error rates make accurate genome assembly difficult, while repetitive regions also challenge short-read-based assembly.

  • Method

    The paper experimentally analyzes combinations of basecalling, overlap-finding, assembly, mapping, and polishing tools across the nanopore genome-assembly pipeline.

  • Results

    The study identifies tradeoffs among accuracy, speed, memory usage, and scalability across the analyzed pipeline tools.

  • Takeaways & Limitations

    The observations can guide conscious tool choices for researchers and practitioners and help developers improve or build accurate, fast tools.

  • Takeaways & Limitations

    The analysis is a checkpoint of state-of-the-art tools available when the manuscript was submitted in this fast-moving field.

Abstract

from arXiv · show

Nanopore sequencing technology has the potential to render other sequencing technologies obsolete with its ability to generate long reads and provide portability. However, high error rates of the technology pose a challenge while generating accurate genome assemblies. The tools used for nanopore sequence analysis are of critical importance as they should overcome the high error rates of the technology. Our goal in this work is to comprehensively analyze current publicly available tools for nanopore sequence analysis to understand their advantages, disadvantages, and performance bottlenecks. It is important to understand where the current tools do not perform well to develop better tools. To this end, we 1) analyze the multiple steps and the associated tools in the genome assembly pipeline using nanopore sequence data, and 2) provide guidelines for determining the appropriate tools for each step. We analyze various combinations of different tools and expose the tradeoffs between accuracy, performance, memory usage and scalability. We conclude that our observations can guide researchers and practitioners in making conscious and effective choices for each step of the genome assembly pipeline using nanopore sequence data. Also, with the help of bottlenecks we have found, developers can improve the current tools or build new ones that are both accurate and fast, in order to overcome the high error rates of the nanopore sequencing technology.

1 Introduction

Nanopore sequencing offers long, portable, high-throughput, and potentially low-cost genome sequencing, but high error rates make accurate analysis and assembly difficult. This work evaluates genome-assembly tools to characterize their tradeoffs and bottlenecks.

  • Motivation: Long reads can span repetitive sequences, enabling more continuous and complete assemblies than short reads.Short reads often cannot span entire repeats, causing fragmented and incomplete assemblies.
  • Nanopore sequencing: Nanopore sequencing promises high throughput, low cost, long reads, and no amplification before sequencing.It is a single-molecule technology with several advantages over conventional sequencing workflows.
  • Nanopore sequencing: MinION is a pocket-sized, portable, high-throughput device that produces sequencing data in real time.These properties support applications such as epidemic surveillance and near-patient testing.
  • Challenges: High nanopore error rates remain a major drawback despite accuracy improvements from the R9 chemistry.Faster analysis is also needed to exploit MinION’s real-time data production and enable real-time analysis.
  • Study objective: The study analyzes genome-assembly tools across accuracy, speed, memory efficiency, and scalability to identify advantages, disadvantages, and bottlenecks.It examines multiple pipeline steps and associated publicly available tools.

2 Genome Assembly Pipeline Using Nanopore Sequence Data

The nanopore genome assembly pipeline proceeds from raw signal through basecalling, overlap finding, assembly, mapping, and polishing, using tools evaluated for different tradeoffs. Its design addresses nanopore reads’ high error rates, with OLC-based assembly preferred for long, error-prone reads.

  • 2.1 Basecalling: Basecalling converts MinION’s raw electric-current signal into DNA reads and is critical for reducing nanopore sequencing errors.Event detection and homopolymer-length estimation are difficult, making deletions the dominant nanopore error.
  • 2.1 Basecalling: RNN-based basecallers such as Metrichor, Nanonet, Scrappie, and DeepNano are contrasted with HMM-based Nanocall.Nanonet is an offline, open-source RNN alternative to Metrichor; Scrappie uses transducer-based basecalling to address homopolymer errors.
  • 2.2 Read-to-Read Overlap Finding: OLC algorithms are used for nanopore reads because short-read de Bruijn graph methods are unsuitable for their high error rates.The overlap stage finds common sequences between reads; GraphMap and Minimap are state-of-the-art tools for this step.
  • 2.2 Read-to-Read Overlap Finding: GraphMap uses a full gapped-k-mer hash table for sensitive overlap detection, whereas Minimap stores minimizers to reduce storage and accelerate searches.Minimap also sorts k-mers for cache efficiency, while GraphMap is described as highly sensitive and accurate for error-prone long reads.
  • 2.3 Assembly: Canu performs error correction before constructing a draft assembly, while Miniasm skips correction to lower computational cost and accelerate assembly.Miniasm’s draft accuracy depends directly on uncorrected read accuracy, so polishing may be necessary; Miniasm does not support multi-threading.
  • 2.5 Polishing: Polishing maps basecalled reads to a draft assembly and changes the assembly to increase local similarity, using tools such as Nanopolish or Racon.Racon uses partial order alignment graphs and is fast, while Nanopolish promises a higher accuracy increase; multiple or combined polishing runs can improve accuracy significantly.

3 Experimental Methodology

The study evaluates nanopore assembly tools using E. coli MinION R9 1D data across accuracy, performance, memory, and scalability dimensions. Experiments use multiple systems and compare draft and polished assemblies against a reference genome.

  • The test case is an Escherichia coli genome sequenced with a MinION using an R9 flowcell.
  • The analysis uses 1D MinION data, in which only the template DNA strand is sequenced.
  • The dataset contains 164,472 fast5 files with raw signal and basecalled data, supporting both local basecalling and analysis of Metrichor reads.
  • Accuracy is measured by assembly size, contig count, identity, coverage, mismatches, and indels against the reference genome.
  • Performance is measured using wall-clock time, CPU time, peak memory usage, and parallel speedup across systems with different specifications.

4 Results and Analysis

The evaluation combines tools across the nanopore assembly pipeline and assesses accuracy, performance, and scalability. It examines basecalling, overlap finding, assembly, polishing, and thread-level behavior.

  • The first analysis combines basecallers with GraphMap or Minimap followed by Miniasm, or with Canu, producing and evaluating draft assemblies.
  • The second analysis evaluates combinations of BWA-MEM or Minimap with Nanopolish or Racon for mapping and polishing draft assemblies.
  • The third analysis varies thread counts for multithreaded tools and measures changes in speed, memory usage, and parallel speedup on two systems.
  • RNN-based basecallers avoid assumptions about sequence length and are not affected by repeats, but homopolymer length remains difficult to determine accurately.
  • Pipelines beginning with Metrichor, Nanonet, or Scrappie show similar identity and coverage trends, while Scrappie has fewer mismatches and indels.

Nanonet.

The basecaller results show accuracy and performance tradeoffs among RNN- and HMM-based tools. Scrappie performs especially strongly, while thread scaling is limited by memory, hardware, and synchronization effects.

  • RNN-based Nanonet, Scrappie, and Metrichor achieve higher identity and coverage trends than Nanocall and DeepNano in the evaluated scenarios.
  • RNN-based Nanonet and DeepNano are 2.6x and 2.3x faster than HMM-based Nanocall, respectively.
  • Scrappie is 5.7x faster than Nanonet, attributed to its C implementation rather than Nanonet’s Python implementation.
  • Scrappie and Nanocall show linear memory growth with thread count, whereas Nanonet maintains constant memory usage across evaluated thread counts.
  • Once thread counts exceed physical cores, simultaneous multithreading overhead prevents continued linear speedup for Nanonet, Scrappie, and Nanocall.
  • Data sharing across NUMA nodes degrades Nanonet’s parallel speedup because non-local memory access has higher latency.

4.2 Read-to-Read Overlap Finding Tools

GraphMap and Minimap provide similar accuracy for read-to-read overlap finding, but Minimap uses less memory, runs faster, and scales better. Its speedup declines beyond 32 threads.

  • GraphMap uses the full k-mer set for overlap finding, whereas Minimap uses a representative subset called minimizers.
  • GraphMap and Minimap produce similar identity, coverage, indel, and mismatch values across evaluated pipelines.
  • Minimap requires 4.6x less memory than GraphMap on average, with memory usage dependent on hash-table size rather than thread count.
  • Minimap is 2.5x faster than GraphMap on average across the evaluated scenarios.
  • After 32 threads, Minimap’s parallel speedup decreases because synchronization overhead increases as threads wait for active workloads to finish.

4.3 Assembly Tools

The assembly-step comparison reveals a clear accuracy–performance tradeoff: Canu produces more accurate assemblies, while Miniasm is much faster but needs polishing for higher final accuracy.

  • Canu provides higher accuracy than Miniasm because its pipeline includes computationally expensive error correction.
  • 1096.3x: Canu is slower than Miniasm because its error-correction step is computationally intensive.
  • Miniasm enables fast initial assembly, whereas Canu produces highly accurate but resource-intensive and slow assemblies.
  • Further polishing can improve low-quality draft assemblies produced by rapid assembly methods such as Miniasm.
  • Read mapping: Minimap2 significantly outperforms BWA-MEM and has similar accuracy and performance to Minimap, supporting its use in future pipelines.
  • Read mapping and polishing: For Racon, BWA-MEM and Minimap produce almost identical polishing accuracy; one example reports 98.46% versus 98.45% identity with 100.00% coverage.

Performance

Performance varies substantially across mapping and polishing tools. Minimap and Racon are faster and less resource-intensive choices, while Nanopolish and BWA-MEM impose greater computational costs and have thread- or input-dependent bottlenecks.

  • Nanopolish: Nanopolish is computationally more intensive and slower than Racon, partly because it processes individual bases and uses raw signal data with an HMM-based approach.
  • Read mapping: Minimap is greatly faster than BWA-MEM, but its performance degrades at high thread counts because of synchronization overhead.
  • Read mapping: 332.0x: Minimap is faster than BWA-MEM on the desktop system on average.
  • Read mapping: Minimap memory usage remains constant across thread counts, whereas BWA-MEM memory usage increases linearly with threads.
  • Racon: Racon memory usage is independent of thread count, but PAF mode uses 1.86x more memory than SAM mode on average.
  • Nanopolish: Nanopolish memory usage depends on segment length: increasing segments from 25kb to 50kb raises memory usage 2.7x and makes runs 2.7x slower.
  • Nanopolish: Nanopolish performance degrades when threads exceed physical cores because hyper-threading increases contention in shared CPU resources.

5 Recommendations

The recommendations prioritize tools according to accuracy, speed, memory use, and scalability across pipeline stages. They favor Scrappie, Minimap, Canu or Miniasm depending on timing needs, and Racon for polishing.

  • Tool users: Scrappie is recommended for basecalling because it is the newest, fastest, and most accurate among the evaluated choices.
  • Tool users: Minimap is recommended for read-to-read overlap finding because it is faster than GraphMap, uses less memory, and has similar accuracy.
  • Tool users: Canu is recommended when execution time is less important because it produces more accurate assemblies.
  • Tool users: Miniasm is recommended for fast initial analysis, followed by polishing to increase final assembly accuracy.
  • Tool users: Racon is recommended for polishing because it is much faster than Nanopolish while producing highly accurate assemblies.
  • Future platforms: Future laptop evaluations should account for greater memory constraints, lower computational power, and limited battery life.
  • Tool developers: Tool developers should consider implementation language, memory hierarchy, cache efficiency, thread scaling, and parallelization overhead.

6 Conclusion

The paper evaluates nanopore genome-assembly pipelines across accuracy, speed, memory efficiency, and scalability, then derives tool-selection guidance and developer-facing bottlenecks.

  • The study analyzes multiple pipeline steps and state-of-the-art tools using accuracy, speed, memory efficiency, and scalability criteria.
  • Scrappie-like accurate basecallers can address nanopore sequencing’s major drawback: high error rates.
  • Minimap and GraphMap have similar accuracy, but Minimap is faster, uses less memory, and is more suitable for memory-constrained machines.
  • Miniasm supports very fast initial assembly, while polishing can increase the accuracy of its final assembly.
  • Racon produces high-quality consensus sequences while providing a significant speedup over Nanopolish.
  • The reported bottlenecks and design effects are intended to guide tool selection and future tool development.

Key Points

The paper evaluates nanopore genome-assembly tools across accuracy, performance, memory usage, and scalability, identifying bottlenecks, tradeoffs, and practical guidance. Its key findings emphasize memory-aware tools, basecalling, and assembly-tool choices.

  • The study analyzes state-of-the-art tools across accuracy, performance, memory usage, and scalability.
  • The experiments reveal bottlenecks and tradeoffs produced by different combinations of nanopore analysis tools.
  • The paper provides guidelines to help practitioners choose tools and combinations and developers improve current and future tools.
  • Memory-hierarchy-aware tools provide better overall performance and scalability, with usability advantages when memory usage remains controlled as threads increase.
  • Basecalling is identified as the most important pipeline step for overcoming nanopore sequencing’s high error rates.
  • Assembly-tool selection involves an accuracy–performance tradeoff: Miniasm with polishing can be faster overall than Canu while producing high-quality assemblies.

Author Details

The authors are researchers working across computational biology, bioinformatics, computer architecture, systems, and related areas.

  • Damla Senol Cali studies computational methods for NGS and nanopore sequencing data analysis and computer architecture.
  • Jeremie S. Kim researches computer architecture and hardware accelerators for bioinformatics applications.
  • Saugata Ghose focuses on computer architecture, including architecture-aware and systems-aware memory and storage.
  • Can Alkan researches combinatorial algorithms for bioinformatics and computational biology.
  • Onur Mutlu researches computer architecture, systems, security, and bioinformatics.
Loading 1711.08774v4…