Solving genomic puzzles: computational methods for metagenomic binning

Abstract

Metagenomics involves the study of genetic material obtained directly from communities of microorganisms living in natural environments. The field of metagenomics has provided valuable insights into the structure, diversity and ecology of microbial communities. Once an environmental sample is sequenced and processed, metagenomic binning clusters the sequences into bins representing different taxonomic groups such as species, genera, or higher levels. Several computational tools have been developed to automate the process of metagenomic binning. These tools have enabled the recovery of novel draft genomes of microorganisms allowing us to study their behaviors and functions within microbial communities. This review classifies and analyzes different approaches of metagenomic binning and different refinement, visualization, and evaluation techniques used by these methods. Furthermore, the review highlights the current challenges and areas of improvement present within the field of research.

Introduction

Metagenomics is the study of genetic content directly obtained from microbial communities found in various environments [1–4] such as soil, seawater, air, and niches of the human body including the respiratory and gastrointestinal tracts. Samples directly obtained from these environments are processed to isolate the genetic material, which is then sequenced to obtain the nucleotide information. This nucleotide information is analyzed to characterize the different microorganisms present in the microbial community and understand their behaviors and functions. With the advent of high-throughput sequencing approaches, metagenomics has enabled the access and study of genomes from entire microbial communities [2, 5, 6], providing valuable insights into their composition and interactions.

A typical metagenomic analysis pipeline starts by obtaining DNA sequences called reads from a metagenomic sample. Next-Generation Sequencing (NGS) technologies (e.g. Illumina [7] and MGI [8]) generate short reads typically ranging from 50 to 300 base pairs (bp) and are widely used for metagenomic studies. Third Generation Sequencing (TGS) technologies [9] (e.g. Pacific Biosciences and Oxford Nanopore Technologies) that produce long reads typically ranging from 10 kbp to over 1 Mbp recently have gained popularity as well. Then, a process known as assembly is used to connect the sequenced reads to reconstruct the original genome from which the DNA originated [10–12]. This task is computationally challenging because essentially every read must be compared to every other read, and the number of comparisons increases with the square of the number of reads. Sequence assemblers produce longer sequences called contigs which can further be connected to form scaffolds. Metagenomic data is both noisy and redundant; variation in the sequences may arise from sequencing errors or different species in the original samples with different, but highly related sequences. Specialized assemblers known as metagenome assemblers [13] employ heuristics so that they can assemble metagenomic data in a reasonable time (e.g. MEGAHIT [14], metaSPAdes [15] for NGS data, and metaFlye [16] for TGS data). However, they do not always produce complete/near-complete genomes due to the complex composition of metagenomes and the complexity of the calculations. Hence, metagenomic binning and refinement methods are employed to recover draft genomes known as metagenome-assembled genomes (MAGs). In most binning methods, taxonomy-independent, unsupervised techniques are used to place metagenomic sequences into imaginary bins that represent different taxonomic groups such as species, genera, or higher levels [17]. Metagenomic binning solutions have advanced microbial ecology by providing information about community structures, improved human health through pathogen identification and gut microbiome analysis, and progressed biotechnology by enabling the discovery of novel enzymes and metabolic pathways [18–20].

Only a limited number of reviews have been conducted on the computational methods used in taxonomy-independent metagenomic binning [13, 17, 21]. Moreover, new binning methods incorporating new features and techniques have emerged recently. Hence, this review aims to deliver a comprehensive overview of the different types of metagenomic binning methods (Fig. 1), discuss their challenges, study new trends and highlight the areas that require improvement. It must be noted that this review does not focus on benchmarking binning methods, as detailed benchmarking studies on various datasets have already been published [22–26]. This review is a comprehensive starting point for beginners entering the field of computational metagenomics and will pave the way for improvement in the research field.

Figure 1.

Aspects of metagenomic binning. After obtaining sequences from a metagenome, reads can either be directly binned for partitioned assembly or first assembled into contigs and then binned. Features such as composition, abundance and graph structures of sequences are used during binning. Obtained bins can be refined, visualized, and evaluated prior to obtaining the final set of metagenome-assembled genomes (MAGs).

Features used in metagenomic binning

Metagenomic binning is a clustering problem. To cluster sequences, we must obtain a set of features that characterize the sequences. This section presents the main features used in metagenomic binning; the classic features include (i) nucleotide composition, (ii) abundance, and, more recently, (iii) graph structures of sequences and other biological information (e.g. special genes and constraint information) (Fig. 2). We also present available tools and summarize their details obtained through their relevant publications, published software repositories, and source code.

Figure 2.

Features used in metagenomic binning. The main features include (A) nucleotide composition, (B) abundance, (C) graph structures of sequences, and (D) other features such as special genes and constraint information.

Nucleotide composition

The frequencies of oligonucleotides in genomic sequences (referred to as k-mers) carry taxonomy-specific signals [27, 28]. Composition-based methods have been developed based on the assumption that each taxonomic group has a unique nucleotide composition, and thus their sequences can be separated into bins by comparing the nucleotide content [17], such as the guanine-cytosine (GC) content [29] and normalized frequencies of oligonucleotides [30].

Normalized frequencies of oligonucleotides, especially tetramers or 4-mers [29–36], have become the most popular method to represent the nucleotide composition of sequences in a numerical manner that can be used in computations. Other oligonucleotides such as pentamers [37–40] and hexamers [41] have been used as well. We start by determining all the possible substrings of a given length k (which is why they are known as k-mers) for a given sequence. This is done using a sliding window of size k across the sequence so there are 4^k possible k-mers. Next, we count how many times each k-mer appears in the sequence and obtain a k-mer frequency vector with the lexicographic ordering of the k-mers. As DNA is double-stranded and sequencers can sample fragments from both strands, we often combine the counts of each k-mer with its reverse complement, thus reducing the dimension of our k-mer frequency vector to 4^k/2 if k is odd or (4^k + 4^k/2)/2 if k is even [32, 42]. Finally, all the k-mer counts are normalized by the total number of k-mers found in the sequence, resulting in a normalized k-mer frequency vector (Fig. 2A). This normalization assumes that all k-mers are equally likely, but the likelihood of each k-mer depends on the nucleotide composition of the genome. Therefore, other means of representing k-mers include (i) likelihood representations [37, 43] that model the probability of observing a sequence given the k-mer distribution of the genome from which the sequence originates and (ii) Chaos Game Representation (CGR) [44] that provides a visual method for representing one-dimensional sequences as distinctive graphical images enabling pattern identification.

Once the nucleotide composition is obtained, various statistical methods and machine learning-based approaches can be used to cluster the sequences into bins. Table 1 summarizes some of the notable metagenomic binning tools that use composition features.

Table 1.

Comparison of metagenomic binning tools that use composition features

Binning tool	Year	User interface *	Programming languages used	Sequences binned	Minimum length cut-off (bp)	Main features, techniques, models or algorithms used
TETRA	2004	Web GUI	N.D.†	Fragments	1000	4-mers and Maximal-order Markov models
CompostBin	2008	CLI	C and Matlab	Short reads	1000	6-mers, weighted Principal Component Analysis and Normalized Cut clustering algorithm
LikelyBin	2009	CLI	Perl and C	Short reads	400	1-mers to 5-mers and Markov chain Monte Carlo (MCMC) methods
MetaCluster 2.0	2010	CLI	C	Fragments	300	4-mers and k-means clustering based on Spearman footrule distance
SCIMM	2010	CLI	Python, C and Matlab	Reads and contigs	400	Interpolated Markov models
MetaCluster 3.0	2011	CLI	C	Fragments	500	4-mers and k-median clustering based on Spearman distance
2Tbinning	2012	N.D.	N.D.	Contigs	N.D.	4-mers and Gaussian mixture models
BiMeta	2015	N.D.	N.D.	Short reads	N.D.	4-mers and k-means clustering
VizBin	2015	Desktop GUI	Java	Contigs and long reads	1000	5-mers, Barnes-Hut stochastic neighbor embedding and manual clustering
MetaProb	2016	CLI	C++	Short reads	N.D.	4-mers and k-means clustering
BusyBee Web	2017	Web GUI	N.D.	Contigs and long reads	500	5-mers and bootstrapped supervised binning
MetaProb 2	2021	CLI	Python and C++	Short reads	N.D.	4-mers and Louvain community detection algorithm

^*CLI, Command line interface; GUI, Graphical user interface.

^†N.D., Not defined, no details provided or not available publicly.

Abundance

Methods based on nucleotide composition encounter difficulties when binning sequences from genomes with high genomic similarity [45, 46] and species with low abundance [21]. However, each component of a genome should be present in the sample in the same proportion. Thus, by estimating the abundance of sequences (contigs or reads), we can identify sequences originating from the same chromosome because they should have the same abundance in each sample. These sequences should also belong to the same organism because they should have the same proportion in each sample. Hence, abundance-based binning methods were introduced to overcome the challenges of composition-based methods. These methods have shown improved results for sequences of closely related organisms (e.g. strains of the same species) that have similar composition profiles [21].

Abundance calculations can vary based on the type of sequences binned. The abundance of contigs is generally represented by the coverage which is the average number of reads that align to each base of the contig. This approximates how many copies of that genome are present in the sample. Contig coverage can be calculated by mapping all the reads to the assembled contigs and counting how many reads map to each base of the contig (Fig. 2B). If the contigs are obtained from a cross-assembly of multiple samples (i.e. reads from multiple samples are combined and assembled) or individual assemblies of multiple samples, the reads from individual samples can be mapped to the contigs. Then the coverage for each contig in each sample can be calculated, resulting in a coverage vector for each contig. Recent studies have shown improved binning results of such multi-coverage binning approaches [47].

The abundance of a read in a given dataset involves determining how many overlapping reads can be found within the set of all reads obtained from the given metagenomic dataset. This can be calculated by performing all-vs-all pairwise alignments of reads. We can also use k-mers from reads to calculate the k-mer coverage [48]. The k-mer coverage is defined as the average number of reads covering that k-mer in a genome. The k-mer coverage can be calculated by counting the number of times k-mers are found in the set of reads. The k-mer coverage values for all k-mers in a read can be obtained to form a feature vector or a k-mer coverage histogram [48–51] representing the read.

Abundance-based binning methods can be subdivided into methods that bin (i) a single sample (e.g. AbundanceBin [52] and MBBC [53]) and (ii) multiple samples (e.g. Canopy [54]). Methods using a single sample assume that sequencing follows the Lander-Waterman model [55], meaning that the number of times a base is sequenced follows a Poisson distribution. Methods using multiple samples assume that abundance profiles of sequences vary with changes in the abundance of the underlying organisms across samples or differential abundance [17, 21, 56].

Once the abundance profiles are extracted, various statistical methods and machine learning-based approaches can be used to cluster the sequences into bins. Table 2 summarizes some of the popular metagenomic binning tools that use abundance features.

Table 2.

Comparison of metagenomic binning tools that use abundance features

Binning tool	Year	User interface *	Programming languages used	Sequences binned	Number of samples	Minimum length cut-off (bp)	Main techniques, models or algorithms used
AbundanceBin	2011	CLI	C++	Reads	One	75	Expectation- Maximization algorithm
Canopy	2014	CLI	C++	Genes	Multiple	N.D.†	Agglomerative clustering based on statistical measures
MBBC	2015	Desktop GUI and CLI	Java	Reads	One	75	Expectation- Maximization algorithm and Markov chains

^*CLI, Command line interface; GUI, Graphical user interface.

^†N.D., Not defined, no details provided or not available publicly.

Composition and abundance combined

Composition and abundance-based methods (or hybrid methods) make use of both the variation of oligonucleotide frequencies and coverage information. Once the nucleotide composition and abundance features are calculated for each sequence, they can be either combined (e.g. form a concatenated feature vector for each sequence [19, 57]) to perform clustering or can be used hierarchically (e.g. first cluster using composition features and then using abundance features [48]). These methods have often outperformed composition-based methods and abundance-based methods. Hence, hybrid binning tools have become the preferred choice for binning metagenomic datasets at present.

Once both the composition and abundance features are obtained, techniques such as principal component analysis (PCA), probabilistic models, expectation maximization algorithms and, more recently, machine and deep learning models have been used to develop these hybrid binning tools. Table 3 summarizes some of the popular hybrid metagenomic binning tools.

Table 3.

Comparison of hybrid metagenomic binning tools

Binning tool	Year	User interface *	Programming languages used	Sequences binned	Minimum length   cut-off   (bp)	Main techniques, models or algorithms used
MetaWatt	2012	Desktop GUI and CLI	Java	Contigs	300	Interpolated Markov models
MetaCluster 4.0	2012	CLI	C	Short reads	75	K-median clustering based on Spearman distance
MetaCluster 5.0	2012	CLI	C	Short reads	75	K-means clustering based on the Spearman distance
GroopM	2014	CLI	Python	Contigs	1000	Heat maps and Gaussian blur filters
MaxBin	2014	CLI	C++ and Perl	Contigs	1000	Expectation maximization algorithm
CONCOCT	2014	CLI	Python, C and Perl	Contigs	1000	Gaussian mixture model fit with a variational Bayesian approximation
MetaBAT	2014	CLI	C++	Contigs	2500	Modified k-medoid clustering algorithm
ABAWACA	2015	CLI	C++	Scaffolds	5000	Iterative splitting
MaxBin 2.0	2016	CLI	C++ and Perl	Contigs	1000	Expectation maximization algorithm
MyCC	2016	CLI	Python	Contigs	1000	Affinity propagation
COCACOLA	2016	CLI	Matlab	Contigs	1000	K-means clustering with L1 distance
BinSanity	2017	CLI	Python	Contigs	2500	Affinity propagation
CoMet	2017	CLI	R	Contigs	1000	DBSCAN clustering
BMC3C	2018	CLI	N.D.†	Contigs	1000	Ensemble k-means and graph partitioning using normalized cut
GATTACA	2018	CLI	Python and C++	Contigs	1000	Gaussian mixture model with a Dirichlet prior
SolidBin	2019	CLI	Python	Contigs	1000	Constraint-based spectral clustering with normalized cut
MetaBAT 2	2019	CLI	C++	Contigs	1500	Graph partitioning using a modified label propagation algorithm
MetaBCC-LR	2020	CLI	Python and C++	Long reads	1000	Probabilistic sampling and Barnes-Hut t-distributed stochastic neighbor embedding (BH-tSNE)
VAMB	2021	CLI	Python	Contigs	100	Variational autoencoders and iterative medoid clustering
LRBinner	2022	CLI	Python and C++	Long reads	1000	Variational autoencoders and histogram-based clustering
CH-Bin	2022	CLI	Python	Contigs	1000	Convex hull-based clustering
SemiBin	2022	CLI	Python	Contigs	2500	Siamese neural network and Infomap clustering
MetaDecoder	2022	CLI	Python	Contigs	2500	Dirichlet process Gaussian mixture model
binny	2022	CLI	Python and Perl	Contigs	500	Fast Fourier Transform-accelerated Interpolation-based t-distributed Stochastic Neighbor Embedding
CLMB	2022	CLI	Python	Contigs	N.D.†	Variational autoencoders and iterative medoid clustering
SemiBin2	2023	CLI	Python	Contigs and long reads	2500	Siamese neural network, Infomap clustering (contigs), and an ensemble clustering method based on DBSCAN (long reads)
AAMB	2023	CLI	Python	Contigs	2000	Adversarial autoencoders
COMEBin	2024	CLI	Python	Contigs	1000	Feed-forward neural networks and Leiden-based clustering

^*CLI, Command line interface; GUI, Graphical user interface.

^†N.D., Not defined, no details provided or not available publicly.

As shown in Table 3, most of the tools are designed for contigs and developed as command line tools. Moreover, most tools have a contig cut-off length of 1000 bp that discards short sequences. Furthermore, these tools use various traditional clustering methods (e.g. k-means, k-medoids and DBSCAN) [57–65], traditional machine learning techniques (label propagation and Gaussian mixture models) [19, 66–68] and deep learning techniques (variational autoencoders [69, 70], Siamese neural networks [71, 72]. adversarial autoencoders [73] and feed-forward neural networks [74]) to bin sequences.

The number of unique k-mers increases exponentially with the increasing size of k. Hence, most binning tools only consider one k value to represent the nucleotide information. The most popular k-mer size is k = 4 (tetranucleotides), as it results in a reasonably long feature vector with 136 dimensions after combining reverse complements. Some tools use trinucleotides (e.g. MetaBCC-LR [48] and LRBinner [50, 51]) that will further reduce the vector space to 32 dimensions. However, some tools use the nucleotide composition from a combination of small k-mer sizes (e.g. ABAWACA [75] uses k = 1,2,3 and binny uses k = 2,3,4). Furthermore, tools such as CH-Bin [76] implement high-dimensional clustering techniques that use combinations of slightly larger k-mer sizes (k = 4,5,6 by default) for binning, thus increasing the resolution of composition patterns.

Early binning tools used nucleotide composition and coverage to perform stepwise binning. For example, GroopM [77] mainly uses differential coverage patterns across multiple samples to bin contigs. The bins are refined by splitting and merging operations based on the nucleotide composition and marker gene information. However, recent tools have combined both the coverage and nucleotide composition features either into one single concatenated vector for each sequence (e.g. CONCOCT [19] and SolidBin [63]) or into one probabilistic or distance metric (e.g. MaxBin [78], MaxBin 2.0 [79], MetaBAT [60], and MetaBAT 2 [80]). Normalization techniques such as normalizing over sequence lengths, normalizing over samples and z-scaling are used when combining the coverage and nucleotide composition features. Also, the concatenated vectors can have a large number of dimensions and can affect the efficiency of the downstream clustering steps. Hence, dimension reduction techniques such as PCA and Barnes-Hut t-distributed stochastic neighbor embedding (BH-tSNE) are employed to obtain a low-dimensional representation of the feature space [48, 81]. These techniques have markedly enhanced the speed and performance of metagenomic binning tools, allowing them to handle large-scale metagenomic datasets.

Graph structures of sequences

Until the late 2010s, metagenomic binning methods mainly relied on the nucleotide composition and abundance features to bin sequences. In most binning tools, sequences are represented as feature vectors and binning is done based on distance or probability calculations. These tools treat sequences as individual data points rather than considering that some sequences may originate from consecutive genomic regions.

A graph is a data structure consisting of a set of vertices or nodes and a set of connections between vertices known as edges [82]. In some graphs, the edges can have weights that represent the strength of the connection. Graphs can represent complex relationships and neighborhood information among their nodes that may not be captured in the Euclidean or probabilistic space. Hence, metagenomic binning has shifted towards using graph structures to represent sequences in binning.

Tools such as MetaBAT 2 [80] build a graph using feature similarity between contigs. However, these graphs lack the location, orientation and connectivity information of contigs within the constituent genomes. Graph structures containing contigs and their orientation information were already available from metagenomic assemblers in the form of assembly graphs and metagenomic studies have been using assembly graphs for the manual curation of contigs [83]. Subsequently, assembly graphs [84, 85] and other graph structures, such as Hi-C contact maps (e.g. bin3C [86] and HiCBin [87]) and read overlap graphs (e.g. OBLR [88]) were introduced in automated binning tools (Fig. 2C). Table 4 presents a comparison of metagenomic binning tools that use special graph structures.

Table 4.

Comparison of metagenomic binning tools that use special graph structures

Binning tool	Year	User interface *	Programming languages used	Graph structure used	Main techniques, models or algorithms used
bin3C	2019	CLI	Python	Hi-C contact maps	Infomap clustering algorithm
MetaCoAG	2022	CLI	Python	Assembly graph	Graph matching and label propagation
RepBin	2022	CLI	Python	Assembly graph	Graph convolutional networks
OBLR	2022	CLI	Python and C++	Read overlap graph	Graph Sample and Aggregate (GraphSAGE)
GraphMB	2022	CLI	Python	Assembly graph	Variational autoencoders and Graph Neural Networks
HiCBin	2022	CLI	Python	Hi-C contact maps	Leiden clustering algorithm
CCVAE	2022	CLI	Python	Assembly graph	Connectivity-constrained variational autoencoders
UnitigBIN	2024	CLI	Python	Assembly graph	Variational autoencoders and graph convolutional networks
hmBin	2024	CLI	Python	Assembly graph	t-distributed stochastic neighbor embedding (tSNE) and a distance-based clustering algorithm

^*CLI, Command line interface.

Recently, assembly graphs have become the most common graph structure used to represent contigs in metagenomic binning, as they are readily available from the assembler output. Assemblers start by identifying overlaps between sequences (it can be reads or k-mers depending on the assembly paradigm [12]) and form a graph structure where sequences are vertices and overlaps are edges [89, 90]. After performing several simplification steps we get the final assembly graph where vertices represent contigs and edges represent overlaps between the contigs [15]. Normally these overlaps represent prefix-suffix overlaps (i.e. the suffix of the first contig overlaps the prefix of the second contig) denoting that the two contigs are placed one after the other along their genome with relevant orientation information (Fig. 2C). With the introduction of the assembly graph as a feature in automated metagenomic bin refinement [84], many stand-alone metagenomic binning tools that incorporate the connectivity information of assembly graphs (e.g. MetaCoAG [45, 46], RepBin [91], GraphMB [92], CCVAE [93], UnitigBIN [94], and hmBin [95]) have been developed (Table 4). Moreover, read binning tools such as OBLR [88] employ read overlap graphs that hold neighborhood information of overlapping reads. The use of the read overlap graph has greatly increased the accuracy of binning yet requires efficient means to handle large overlap graphs with millions of reads.

Other features

In addition to the primary binning categories mentioned above, some tools have used other features to perform metagenomic binning and improve the binning results (Fig. 2D). BMC3C [62] utilizes codon usage in addition to the composition and coverage information. COCACOLA [57] considers linkage information from paired-end reads to improve the binning process, although that information is also included in some of the assembly graphs. mBin [96] and nanodisco [97] use bacterial DNA methylation profiles to accurately map mobile genetic elements to their corresponding host bacterial bins.

Another common feature used to assist binning is single-copy marker genes (Fig. 2D). Single-copy marker genes are special genes found in the majority of bacterial genomes and they appear only once in each genome [78, 98, 99]. Hence, some binning tools have utilized single-copy marker genes to estimate the number of bins during binning and to refine the binning results. The BV-BRC metagenomic binning algorithm [100], MaxBin [78], MaxBin 2.0 [79], MetaCoAG [45], and SingleM [101] use single-copy marker genes to estimate the number of bins for the initialization of the binning process. Tools such as GroopM [77] and MyCC [64] use single-copy marker genes to refine the final binning results.

Two common constraints, must-link and cannot-link are frequently used to determine whether a pair of contigs should be placed in the same bin or different bins (Fig. 2D). Some tools employ taxonomic annotations to determine must-link and cannot-link constraints. For example, SolidBin [63] aligns contigs to reference genomes and generates must-link constraints if contigs align to the same species and cannot-link constraints if contigs align to different genera. Taxonomic annotations can be obtained using public databases such as the National Center for Biotechnology Information (NCBI) databases [102] or the Genome Taxonomy Database (GTDB) [103].

As viruses do not encode single-copy marker genes, binning tools specifically designed for viruses incorporate virus-specific information for binning; VRhyme [104] uses protein redundancy scores, CoCoNet [105] is trained on the NCBI RefSeq viral database [106], PHAMB [107] uses viral orthologous groups and ViralCC [108] uses virus-host proximity structure. The use of virus-specific information has enabled viral binning tools to recover viral metagenome-assembled genomes (vMAGs) from metagenomic data.

Ensemble binners

Ensemble binners combine the results from multiple metagenomic binning approaches to optimize and improve the accuracy of genome binning results (e.g. DAS Tool [109], MetaWRAP [110], MetaBinner [111], and BASALT [112]). These tools use different metrics and additional information such as single-copy marker genes to determine a set of non-redundant bins from multiple binning results. Table 5 summarizes some of the popular metagenomic ensemble binning tools.

Table 5.

Comparison of metagenomic ensemble binning tools

Binning tool	Year	User interface *	Programming languages used	Features used	Main techniques, models or algorithms used
DAS Tool	2018	CLI	R	Single-copy genes	Iterative selection
MetaWRAP	2018	CLI	Python	Single-copy genes from CheckM	Read mapping and re-assembly
MetaBinner	2023	CLI	Python and Perl	Composition, coverage and Single-copy genes	k-means++ clustering and Binning_refiner
BASALT	2024	CLI	Python	Tetranucleotide frequency and coverage correlation coefficient	Feedforward neural network

^*CLI, Command line interface.

Bin refinement

Bin refinement tools accept a binning result from an existing tool and attempt to improve the quality and accuracy of the resulting genomic bins. Table 6 presents a summary of the available metagenomic bin refinement tools.

Table 6.

Comparison of metagenomic bin refinement tools

Bin refinement tool	Year	User interface *	Programming languages used	Features used	Main techniques, models or algorithms used
Binning_refiner	2017	CLI	Python and R	Sequence similarity	Pairwise nucleotide BLAST
	2017	CLI	Python and C	Dissimilarity between contigs	measure, Markov models and k-means clustering
GraphBin	2020	CLI	Python	Assembly graph	Label propagation
GraphBin2	2020	CLI	Python	Assembly graph and contig coverage	Iterative label propagation
METAMVGL	2020	CLI	Python	Assembly graph and paired-end graph	Multi-view label propagation
UGMAGrefiner	2023	N.D.†	N.D.	Assembly graph	Graph algorithms and Gaussian Mixture models

^*CLI, Command line interface.

^†N.D., Not defined, no details provided or not available publicly.

During bin refinement, several processing steps are performed to improve bins including:

1. Merging bins—bins can be incomplete and fragmented and should be combined to form one bin.

2. Splitting bins—bins can be erroneously merged due to high similarity and should be split into the correct number of bins.

3. Correcting mis-binned sequences—contigs may be erroneously placed into incorrect bins and should be reassigned to their correct bins.

4. Recovering sequences discarded by the initial binning tool—binning tools can discard short sequences (shorter than a given minimum length cut-off) that can contain short repeat sequences. Such short sequences should be placed in their relevant bins.

Early bin-refinement tools make use of sequence similarity within bins for refinement [113, 114]. However, recent tools use the connectivity information of the assembly graph for refinement (e.g. GraphBin [84], GraphBin2 [115, 116], METAMVGL [117] and UGMAGrefiner [118]). The results produced from bin refinement tools can depend on the quality of the initial binning result. In some cases, the errors in the initial binning result can be propagated, leading to even worse results. Furthermore, most of these tools adjust contigs among bins and do not adjust the number of bins during refinement.

Bin visualization

Binning sequences can be challenging to understand with all the complex algorithms and models used. Bin visualization tools can help biologists understand how the sequences were grouped together and even identify potentially incorrect results. For example, visualizing bins can show how similar sequences were clustered, detect anomalies within bins that may indicate mis-binned sequences and determine sequences with irregular coverage patterns. Table 7 summarizes some of the tools that can visualize metagenomic binning results. Some tools are stand-alone binning tools that provide the functionality to visualize bins.

Table 7.

Comparison of metagenomic bin visualization tools

Bin visualization tool	Year	User interface *	Programming languages used	Features used	Main techniques, models or algorithms used
MetaWatt	2012	Desktop GUI and CLI	Java	GC content, coverage and contig length	Contour plots
Blobology (now known as BlobTools)	2013	CLI	Perl and R	GC content and coverage	Scatter plots
GroopM	2014	CLI	Python	Differential coverage	Heat maps and Gaussian blur filters
VizBin	2015	Desktop GUI	Java	5-mer frequency vectors	Barnes-Hut Stochastic Neighbor Embedding (BH-SNE) and scatter plots
gbtools	2015	CLI	R and Perl	GC content and coverage	Scatter plots
BusyBee Web	2017	Web GUI	N.D.†	5-mer frequency vectors	BH-SNE and scatter plots

^*CLI, Command line interface; GUI, Graphical user interface.

^†N.D., Not defined, no details provided or not available publicly.

Most of the visualization tools employ coverage and GC content to visualize bins. They generate coverage versus GC content plots of sequences using different types of plots such as scatter plots [38, 39, 119, 120], heatmaps [77] and contour plots [68]. Tools such as Blobology [119] and gbtools [120] use scatter plots where each point represents a sequence. In contrast, MetaWatt [68] uses contour plots to visualize the boundaries of sequences within bins. Moreover, only a single sample can be visualized in the coverage versus GC content plots. However, gbtools allows the user to visualize differential coverage plots. Furthermore, tools such as Blobology and gbtools can accept taxonomic annotations results or taxonomic markers and represent sequences in corresponding colors.

Bin evaluation

With the availability of metagenomic binning tools and ample computing power, draft microbial genomes are rapidly generated from various environmental samples. To draw reliable conclusions about environmental dynamics from the growing availability of draft microbial genomes, it is crucial to determine the quality of genomes [121, 122]. Moreover, as new metagenomic binning tools are being developed, it is essential to evaluate the accuracy of their results and ensure they operate as desired. Collective efforts have led to the organization of worldwide challenges such as the Critical Assessment of Metagenome Interpretation (CAMI) [23, 26] that have provided gold standard truth datasets to facilitate standard benchmarking of these methods. Several metrics have been proposed to evaluate metagenomic binning results including, precision, recall, F1-score, purity, completeness, and contamination [123, 124]. Table 8 summarizes some of the automated tools that evaluate metagenomic binning results and calculate these quality metrics.

Table 8.

Comparison of metagenomic bin evaluation tools

Bin evaluation tool	Year	User interface *	Programming languages used	Information used	Main techniques, models or algorithms used
CheckM	2015	CLI	Python	Single-copy marker genes	Hidden Markov Model (HMM) profiles
BUSCO	2015	CLI	Python	Benchmarking sets of universal single-copy orthologs (BUSCO)	HMM profiles
AMBER	2018	CLI	Python	Ground truth annotations from CAMISIM or alignment to reference genomes	Calculation of ​​performance metrics used in the CAMI challenges
CheckM2	2023	CLI	Python	Simulated genomes with known levels of completeness and contamination	Artificial neural networks and gradient-boosted decision trees

^*CLI, Command line interface.

CheckM [123] and BUSCO [125] are two popular bin evaluation tools widely used in metagenomic studies. They can determine the quality of MAGs from real metagenomic data as well as benchmark binning results from simulated or mock datasets. To determine bin quality, CheckM uses single-copy marker genes whereas BUSCO [125] uses the benchmarking sets of universal single-copy orthologs (BUSCO) identified using OrthoDB [126]. However, these methods can fail to accurately evaluate genomes from novel lineages due to the lack of high-quality genomes and the absence of certain marker genes. CheckM2 [127] was introduced to overcome these challenges and evaluate genomes/MAGs without directly considering the taxonomic information of marker genes. Moreover, AMBER [124] relies on metrics such as precision, recall, F1-score and Adjusted Rand Index (ARI) based on a known ground truth (where you know the microbial composition of your metagenome and which sequence belongs to which reference genome) [128]. Hence, AMBER can be applied for simulated or mock metagenomes. AMBER is often used during development to evaluate and benchmark tools using datasets with known ground truth. Additionally, assembly evaluation tools such as QUAST [129] and metaQUAST [130] have been used to measure genome completeness after assembling long-read bins [48] and duplication of bin sizes [131].

Discussion

Metagenomic binning tools have encountered rapid growth over the past two decades. Each year, new tools are introduced claiming to be better than existing tools. Figure 3 summarizes 73 tools related to metagenomic binning which have been discussed in this paper based on different aspects (refer to the section ‘Data and code availability’ for links to the details of the tools). Even though new tools are published each year, the field still encounters various challenges and care should be taken to address them wherever possible. In this section, we explore trends, issues, and insights that researchers and developers should consider when creating new metagenomic binning tools.

Figure 3.

Summary plots of binning tools. Summary count plots of tools by (A) binning category, (B) programming languages used, (C) user interfaces provided, (D) types of sequences binned, (E) sequence length cut-off (in base pairs), and (F) cumulative count of tools by year.

Rising use of deep learning techniques

Many recent metagenomic binning tools (those developed since 2021, Table 4) have shown a trend towards using deep learning techniques. The main idea is to learn a low-dimensional representation or embedding of the sequence features and obtain a clustering of these embeddings to produce bins (Fig. 4). VAMB was among the early tools to use deep learning techniques in metagenomic binning. Subsequently, many deep learning-based binning tools emerged, including those using variational autoencoders (CLMB and LRBinner), Siamese neural networks (SemiBin and SemiBin2), feed-forward neural networks (COMEBin) and graph neural networks (RepBin and UnitigBIN). The use of such deep learning techniques has enabled metagenomic binning tools to bin large-scale complex datasets accurately and efficiently.

Figure 4.

Workflow of a typical deep learning-based approach for metagenomic binning. Firstly, features (including nucleotide composition, abundance, graph structures, and other features) are extracted from the metagenomic sequences. Then a low-dimensional representation or embedding of the sequence features is learned using a deep learning model. Finally, the embeddings of the sequences are clustered to obtain bins.

Recently, binning tools have incorporated unsupervised representation learning techniques such as contrastive learning [132] into the process of ​​learning low-dimensional embeddings of sequence features. The goal of contrastive learning is to learn a representation of the data such that similar points are positioned closely within the representation space and dissimilar points are placed at a greater distance from one another. Binning tools such as RepBin have incorporated contrastive learning using must-link and cannot-link constraints based on the presence of single-copy marker genes. If two contigs are connected together in the assembly graph, they are modelled as must-link constraints. If two contigs have the same single-copy marker gene, it means that the two contigs come from two different genomes. Hence, such pairs of contigs are modelled as cannot-link constraints. During the learning process, contigs with must-link constraints are positioned together, and contigs with cannot-link constraints are placed further apart in the learned representation. Such constraints have improved the learning process and produced accurate results.

Machine/deep learning-based metagenomic binning tools can effectively utilize the efficient and enhanced numerical computation capabilities of General-Purpose Graphics Processing Units (GPGPUs/GPUs), making them ideal for binning large-scale metagenomic datasets with millions of sequences. However, most available tools must load the entire dataset into the memory for feature vector calculations, which can be challenging if computational memory is scarce. For very large datasets and specific use cases, batch-wise processing techniques can be beneficial for handling and processing data in machine/deep learning applications.

Incorporation of taxonomic information

There has been a growing interest in using taxonomic information for metagenomic binning. For example, SolidBin and SemiBin2 model must-link and cannot-link constraints using the taxonomic annotations of contigs from databases such as NCBI or GTDB. The viral binning tool CoCoNet is trained on the NCBI RefSeq viral database [106].

The databases used by binning tools are from well-studied organisms and often generalize the strain-level information into more common signatures within species. While such information is sufficient in contrasting species, it may not be adequate to resolve hidden strains that might be driving the differences in an environment. Furthermore, the results are entirely dependent on the chosen database and are susceptible to missing novel species or discarding organisms that are not from a kingdom represented in the chosen databases.

Challenges in biological delineation of metagenomic data

Determining the exact number of underlying genomes in a metagenomic sample is a computationally challenging task. Tools such as MaxBin and SolidBin use counts of contigs containing single-copy marker genes to initialize the number of bins. This initialization method relies on marker genes being properly assembled within contigs and can be affected when marker genes are fragmented across contigs or when the open reading frames cannot be predicted correctly. To overcome this issue, tools such as MetaCoAG have adapted strategies to dynamically adjust the number of bins during the binning process. Moreover, certain tools use alternate approaches such as agglomerative clustering (Canopy), histogram-based clustering (LRBinner), and iterative clustering (VAMB) that do not rely on an initial estimate of the number of bins.

Short sequences may not provide accurate genome-specific signals due to the low resolution in a single sample. The composition profiles of such short sequences can be sparse and highly deviated from that of their constituent genomes. Binning such short contigs solely based on composition and coverage information can be challenging. Hence, the majority of the available metagenomic binning tools discard these short contigs during the binning process (as denoted by the minimum length cut-off in Table 4). Bin refinement tools such as GraphBin and GraphBin2 have utilized the connections between short contigs and large components in the assembly graph to accurately place them in their corresponding bins. It is worth exploring such methods to recover these short contigs as they can contain useful biological information including short repetitive sequences in viruses [133].

As microbial communities can be composed of different taxonomic groups, the sequencing data obtained from these samples can be very complex and heterogeneous. Even for the same genus, there can be several different species with very similar genomic signatures, and they may co-exist in similar abundance. Moreover, analyzing strain-level variations of species can be a computationally challenging task. Most of the binning methods are unable to generate MAGs at strain-level resolution due to their extremely high similarity and poor assembly quality. They often bin contigs from similar strains together and result in highly contaminated bins [23, 95]. Tools such as VAMB [69] have attempted to address this issue by individually assembling samples, binning all the resulting contigs, and separating MAGs from different samples. However, it is still challenging to recover strain-level MAGs within a single sample due to their highly similar genomic composition and the inherent problems in assembly. Hence, further investigation is required to develop methods capable of recovering MAGs of closely related microorganisms. While this problem may not be entirely solvable computationally due to the high similarity of contigs from different strains, combining long-read and short-read sequencing techniques, along with tools designed to handle both types of data, could offer a viable solution.

Different bacterial genomes in a metagenomic sample may share similar genes and genomic regions [1], which is a major challenge in assembling metagenomic reads into contigs [15]. Therefore, some assembled contigs may be shared by multiple genomes in the sample. However, most of the binning tools will assign these contigs to a single bin based on feature similarity to simplify the computational process. This can affect the completeness of the MAGs constructed afterwards. Very few binning tools support overlapped binning where shared contigs are assigned to their corresponding bins. Among such tools, GraphBin2 has attempted to address this challenge using the assembly graph and coverage information of contigs (e.g. if a contig is shared between two genomes, then its coverage will be elevated and should be close to the sum of the coverages of the two genomes). As shared contigs correspond to shared vertices between different genomic paths on the assembly graph [15], it is worth exploring methods to infer such shared contigs from the assembly graph without additional sequencing requirements.

Most metagenomic binning tools focus only on bacteria and archaea (especially those that rely on bacterial and archaeal single-copy marker genes). Such tools can incorrectly bin or even discard viral sequences as viruses lack universal marker genes [134]. Moreover, micro-eukaryotes such as fungi and protists remain under-characterized in metagenomic studies even though it is possible to adapt existing methods based on their single-copy marker genes [135, 136]. However, identifying fungal genomes is challenging as some DNA sequences can be mixed with closely related genera and require multiple molecular markers and precise sequence selection methods from databases [137, 138]. For example, the nuclear ribosomal RNA (rRNA) gene internal transcribed spacers (ITS) region, widely used for fungal identification, includes ITS1, 5.8S gene, and ITS2, but lacks sufficient resolution power for differentiating closely related fungi. Prahl et al. [137] demonstrated that combining ITS2 sequences and their secondary structures can effectively differentiate true Ampelomyces ITS sequences from incorrectly identified ones derived from environmental DNA. Additionally, the complexity of eukaryotic gene architecture, particularly exon-intron structures, complicates binning efforts. Moreover, the current lack of comprehensive eukaryotic databases impedes marker gene-based analyzes. To address these challenges, there is a clear need for metagenomic tools that focus on a more holistic approach to binning while maximizing the use of kingdom-specific information.

Issues with binning methods

Previous studies have shown that the nucleotide content of certain bacterial genomes can vary locally along chromosomes, especially in terms of GC content [139, 140]. For example, protein-coding regions tend to have higher GC content than non-coding regions [141]. The nucleotide composition of microbial genomes can vary based on factors such as genome size, oxygen requirement and nitrogen abundance [142–144]. Moreover, repeat regions, low complexity regions, homopolymer stretches, library preparation steps, and sequencing biases can result in genomic sequences with uneven sequencing coverage. Hence, there can be high variance in nucleotide composition and abundance features even among the sequences that originate from the same genome. Such genomic sequences that do not match either the average nucleotide composition of the genome or the average abundance of the genome are often incorrectly binned [45]. Approximately one-third of the genes do not match the modal codon usage of their genomes [145] and thus are likely to be misplaced in bins. These genes are often acquired through horizontal gene transfer (e.g. plasmids and mobile genetic elements like prophages). Moreover, prophages have different GC composition compared to the bacterial chromosome backbone [146] precluding them from binning.

During the assembly process, very similar reads are collapsed into single contigs, and then when reads are mapped back to estimate coverage, those contigs appear over-represented compared to their cognate genome. Highly conserved regions including rRNA gene repeats and genes encoding transfer RNA (tRNA) are frequently mis-binned due to their high similarity and repetitive nature, and many bins do not contain any rRNA encoding regions. Similarly, repetitive sequences like transposable elements (including transposons and insertion sequences) and bacteriophages are also rarely binned correctly. Additional steps may be required at the end of binning to accurately add these sequences back to their appropriate genomes, such as marker gene analysis. Marker gene analysis, using databases such as Rfam [147, 148] or SILVA [149], can help identify and potentially correct the placement of rRNA and tRNA genes in bins.

Software best practices

Many metagenomic binning tools are available as open-source software through public software repositories such as GitHub and Bitbucket. Even though most of them are CLI-based software (Fig. 3C), authors should ensure that their code is easy to install, executable, and well-maintained, especially around dependency updates. Proper testing should be carried out before publishing software to ensure that the core algorithms work as desired and produce the correct outputs. Simple test data sets should be included in the installation process so that users can quickly ascertain they are achieving expected outcomes. Software repositories such as GitHub and Bitbucket support continuous integration where workflows for automated building and testing can be set up before merging the changes to the main repository. Furthermore, software should be well-documented with detailed instructions on how to install and execute.

Some binning tools require certain additional files as input for calculations, e.g., Binary Alignment Map files to calculate the average coverage of contigs. Instead of executing these commands separately, one seamless workflow providing these pre-processing steps and the binning tool in just one command would be ideal. For this purpose, we can use workflow managers such as Snakemake [150] or a workflow template such as Snaketool [151]. Moreover, containerized binning tools, especially those utilizing software like Docker to bundle code and all necessary dependencies, are becoming popular as they allow the tools to run quickly and reliably on different computers. However, licensing issues, including potential incompatibilities between open-source software licenses, can sometimes hinder their widespread adoption and publication. Binning tools can also be published on package managers such as Bioconda and PyPI for Python, CRAN for R, or CPAN for Perl. Authors should take advantage of these platforms and services to ensure that the tools are correctly distributed, installed, and run.

Moving beyond binning to obtain contiguous genomes

Most of the available metagenomic binning tools produce MAGs with contigs in a random order. The contigs are not ordered as they are found in the genome and binning tools do not resolve genomic paths from contigs (i.e. determine the ordering of contigs in the genome). This can also be challenging, especially for large genomes such as those from bacteria or micro-eukaryotes as they can result in tangled and complex assemblies from NGS data. One solution is to extract just those reads that appear in each bin, and separately assemble the reads, without the confounding issues associated with the rest of the metagenome sequences [152]. Another alternative is to bin contigs and resolve the contigs in MAGs to construct complete and contiguous genomes. This has been done for bacterial MAGs to reconstruct strains in STRONG [153] and vMAGs to obtain contiguous bacteriophage genomes in Phables [133]. The assembly graph is the key feature used to determine the order of contigs. The connectivity information of contigs from the assembly graph is used to determine genomic paths and resolve representative genomes.

With the rising developments in TGS technologies, particularly longer read lengths that can span repetitive regions and provide increased overlap between reads [154], along with reduced error rates, it is now possible to obtain near-finished bacterial genomes, even from metagenomes [155]. Hence, it is worth exploring methods to move beyond binning and produce not just a set of contigs that constitute a genome, but to connect these contigs and produce the contiguous genome.

Conclusion

The history of metagenomic binning tools dates back to the early 2000s when they were created to automate the process of binning short DNA fragments obtained from environmental samples [156, 157]. Since then, various approaches have been introduced to bin different types of sequences such as short reads, assembled contigs and even error-prone long reads. This article presented a review of metagenomic binning tools and the various aspects including refinement, visualization, and evaluation. Recently, binning tools have incorporated new features such as graph data structures (e.g. assembly graph and read overlap graph) to capture accurate neighborhood information of sequences. The combination of all these features has advanced the recovery of microbial genomes from environmental samples.

Finally, we have discussed new trends in metagenomic binning and existing challenges, despite the significant advances in binning algorithms. Addressing these issues requires a collective effort from the scientific community and well-established community standards. As we move forward, more deep learning-based solutions will emerge, allowing the field of metagenomics to study large-scale metagenomes while harnessing the power of machine learning techniques and high-performance computing platforms. Moreover, attention should be paid to software best practices and making tools more user-friendly, which will widen the user base of binning tools. Overcoming these challenges will allow us to fully harness the capabilities of metagenomic binning approaches, thereby further facilitating pioneering discoveries in the fields of microbial ecology, human health, and biotechnology.

Key Points

• Metagenomic binning is a crucial step in metagenomic analyzes that allows the study of uncultured microorganisms. It involves clustering DNA sequences obtained from environmental samples into bins representing different taxonomic groups.

• Classic features such as nucleotide composition and abundance, and novel features including special graph structures of sequences used in existing metagenomic binning tools are compared in this study.

• New trends including the rising use of deep learning techniques and challenges such as the biological delineation of closely related taxonomic groups are discussed, and further avenues of improvement are presented.

• Researchers should be aware of the challenges associated with metagenomic binning and carefully evaluate their binning results to fully leverage metagenomic binning approaches.

Funding

This work is supported by the National Institutes of Health (NIH) National Institute of Diabetes and Digestive and Kidney Diseases [RC2DK116713] and the Australian Research Council [DP220102915].

Data and code availability

The data summarizing the features of the different tools and the code used to draw plots in Fig. 3 can be found at https://github.com/metagentools/metagenomic_binning_review.

Author contributions

All authors participated in the writing of the original draft, as well as its review and editing.