### Datasets

We use the same two datasets used by Orphelia, one for training the neural network models and a second one for testing the MGC algorithm. The first dataset consists of 131 fully sequenced Bacterial and Archael genomes and their corresponding gene annotations obtained from GenBank [17] and the second dataset is comprised of ten Bacterial and three Archael genomes. Hoff et al. [18] list all the genomes used for training the Orphelia neural network in the supplementary materials of their paper and all genomes used for testing in Table 1 of their publication. The n-fold coverage for a genome is defined as the amount of sampled DNA that is equal in total length to n-times as the length of the original genome complete sequence. Fragments of 700 bp are randomly excised to create a 1-fold genome coverage for each genome in the training dataset and a 5-fold coverage for each genome in the testing dataset.

Two additional training datasets (different from the neural network training data) are used for the preprocessing step required in feature extraction. The first dataset is used for preprocessing the codon usage as described in the next section. Sequences are randomly sampled to create a 0.5-fold genome coverage. Annotated genes serve as positive examples (≈ 1.9 × 10^{5} examples) and the longest ORF in each non-coding ORF-set serve as the negative examples (≈ 2.8 × 10^{6} examples). The second dataset is used to preprocess the TIS feature which will be described in the next section. Symmetric windows of 60 bp around the TIS of the previously selected genes in the first dataset serve as positive examples (≈ 1.9 × 10^{5} examples) while similar windows around the remaining start codons forming the ORF-set of each gene serve as negative examples (≈ 5.6 × 10^{6} examples).

ORFs are then extracted from all the fragments and divided into coding and non-coding ORFs based on the annotation of the genome. Two different types of ORFs are obtained. The ORFs that have both the start codon (either ATG, CTG, GTG or TTG) and the stop codon (either TAG, TGA or TAA) are referred to as complete ORFs. Incomplete ORFs are missing the upstream end, the downstream end or both in which case the ORF spans the entire fragment length without any start or stop codons being present. The addition of the incomplete ORFs notion is necessary since the ORFs present in fragments often stretch beyond these fragments making the standard ORF (complete ORFs) definition insufficient. In this paper, we refer to complete and incomplete ORFs simply as ORFs. Only ORFs with a minimal length of 60 bp are considered in both training and testing. Figure 1 illustrates the different locations of an ORF in a fragment. In addition to their DNA sequences, all the extracted ORF sequences are translated into the equivalent amino-acid sequences (for coding) and pseudo-amino-acid sequences (for non-coding).

In order to train the neural network, ORFs are extracted from the neural network training dataset and divided into positive and negative examples. ORFs from annotated genes serve as the positive examples (≈ 2.6 *×* 10^{6} examples) while one randomly selected ORF out of each non-coding ORF-set make up the negative examples (≈ 4.5 × 10^{6} examples).

### The MGC algorithm

MGC is a metagenomic gene caller based on a two-stage machine learning approach similar to that of the state-of-the-art program Orphelia [1]. The first stage consists of linear discriminants that reduce a high dimensional feature space into a smaller one. For example, the linear discriminant for the dicodon usage reduces the 4096 dicodon frequencies into a single feature. However, these features are not linear across the entire GC spectrum. GC-content has a direct effect on codon and amino acid usages which means that fragments with similar GC-content should have similar features. Therefore, building different linear discriminants for each GC range will result in a better linear combination of the feature space which will better characterize the coding class.

Several linear discriminants are trained based on GC-content ranges. First the training data is split into GC ranges which are defined so that the number of training sequences in all these ranges is the same. For example, we first split the GC spectrum into ranges where each partition contains 10% of the sequences in the training data, then we use the data from each range to create all the necessary discriminants to compute the features. Step 1 in Figure 2 illustrates the linear discriminant stage of MGC for a particular GC range and shows all nine features used in the second stage of the MGC algorithm.

For each GC range we obtain a model using features computed from all the sequences in the training dataset that have GC-content within the GC range. The same GC ranges used to compute the linear discriminants are used to build the neural network models. Different partitionings by GC-content are used to study the effect of the GC range size on the performance of MGC. In this paper we investigate the outcome of MGC models trained by partioning the training data into 10%, 5% and 2.5% ranges. For the remaining of this paper, we refer to these ranges as the 10%, 5% and 2.5% GC ranges.

Once the models are trained, all possible complete and incomplete ORFs are extracted from the input fragment and their corresponding features are extracted using the same linear discriminant step used for training. Based on the GC-content of the fragment, the corresponding neural network model is used to score the ORF. The output of the neural network is the approximation of the posterior probability that the ORF is coding. Step 2 in Figure 2 illustrates the neural network model. Once all input ORFs are scored by the neural networks, the same greedy algorithm used by Orphelia is deployed to resolve the overlap between all candidate ORFs that have a probability greater than 0.5. Given the candidate list for a particular fragment containing all ORFs *i* with probability *P*_{
i
} *>* 0.5, Algorithm 1 describes the selection scheme used to generate the final list of genes. The maximum allowed overlap is *o*_{
max
} = 60 *bp* which is the minimal gene length considered for prediction. A more reasonable overlap would be 45 bp which is believed to be the maximum overlap for bacterial genes. We use the same overlap used by Orphelia for comparison reason. However, the overlap is a variable that the user can change.

**Algorithm 1** The final candidate selection

**while** is nonempty **do**

Find *i*_{
max
} = argmax_{
i
} *P*_{
i
} with respect to all ORFs i in

Move ORF *i*_{
max
} from to

Remove all the ORFs in that overlap with ORF *i*_{
max
} by more than *o*_{
max
}

**end while**

### Features

In order to train the models in MGC we use the nine features (monoamino-acid discriminant, diamino-acid discriminant, monocodon discriminant, dicodon discriminant, two TIS features, two length features and the GC-content). Similarly to standard discriminant codon features, the amino discriminant features are derived from amino acid usage. The monoamino-acid usage is based on the 21 (20 amino-acids plus "STOP") amino-acid frequencies that represent the occurrences of successive single amino-acids in the training sequences while the diamino-acid usage is derived from the 21^{2} diamino-acid frequencies which represent the occurrences of successive half-overlapping amino acid tuples in the training sequences. Linear discriminant analysis based on the monoamino and diamino-acid usage is then used to reduce this high dimensional space to two features. The linear discriminants **w**_{
MA
} and **w**_{
DA
} for the amino-acid features are described by the following equations:

{w}_{MA}={\left({X}_{MA}{X}_{MA}^{T}+\lambda nI\right)}^{-1}{X}_{MA}{y}_{M}

(1)

{w}_{DA}={\left({X}_{DA}{X}_{DA}^{T}+\lambda nI\right)}^{-1}{X}_{DA}{y}_{D}

(2)

Where **X**_{
MA
} and **X**_{
DA
} represent the monoamino and diamino-acid usage respectively, λ is the regularization parameter and **y**_{
M
} and **y**_{
D
} represent the sequence labels for the data points in **X**_{
MA
} and **X**_{
DA
} respectively ({y}_{M}^{i}\in \left\{-1,1\right\} represents whether sequence *i* is a positive example \left({y}_{M}^{i}=1\right) or a negative example \left({y}_{M}^{i}=-1\right)). The linear discriminants for codon features are computed similarly. The monoamino-acid and diamino-acid features are then obtained simply as *x* = **w**_{
MA
} *·* **x**_{
MA
} and *x* = **w**_{
DA
} *·* **x**_{
DA
} respectively.

### Neural networks

The resulting nine features for all the training examples in each GC range are combined in a non-linear fashion using a neural network. The output of each network is the posterior probability of an ORF encoding a protein. We use a standard multilayer perceptron to train the MGC models. This is similar to Orphelia [1] with the exception that we have two more features, and we are training models that are GC range specific. For each GC range we obtain a model using features computed from all the sequences in the training dataset that have GC-content within the GC range. The same GC ranges used to compute the linear discriminants are used to build the neural network models. Different splits by GC-content were used to study the effect of the GC range size on the performance of MGC. In this paper, the MGC models were trained using the 10%, 5% and 2.5% ranges.

The neural network used by Orphelia [18] consists of standard multilayer perceptrons with one layer of k hidden nodes and a single logistic output function is used to train the neural network model. While the classification is setup as a binary classification with labels *y*_{
i
} = 1 for coding and *y*_{
i
} = 0 for noncoding, the output of the neural network is considered an approximation of the posterior probability of the coding class which is used in the final step to select the final ORFs. The k hidden activations *z*_{
i
} for a given input feature vector **x** are:

{z}_{i}=\text{tanh}\left({w}_{I}^{i}\cdot x+{b}_{I}^{i}\right).

(3)

where {w}_{I}^{i} are input weight vectors and {b}_{I}^{i} are the bias parameters.

The prediction function based on weight vector **w**_{
o
} and bias *b*_{
o
} is

g\left(z\right)=\frac{1}{1+\text{exp}\phantom{\rule{0.3em}{0ex}}\left(-{w}_{o}\cdot z-{b}_{o}\right)}.

(4)

where z is a vector containing all the *z*_{
i
} vectors.

The output of the trained network f\left({x}_{i};\theta \right)\phantom{\rule{0.3em}{0ex}}\forall i\in \left(1..N\right) is computed by minimizing the objective function *E*(*θ*) in equation 5 where *x*_{
i
} represent the training examples, *N* is the number of training examples, the weight and bias parameters are referred to by the vector *θ* and the matrix **A** contains the regularization parameters.

E\left(\theta \right)={\displaystyle \sum _{i=1}^{N}}{\left(f\left({x}_{i};\theta \right)-{y}_{i}\right)}^{2}+{\theta}^{T}A\theta .

(5)

The regularization matrix **A** = *diag*(*a* 1, ..., *a* 1, *a* 2, ..., *a* 2, *a* 3, ..., *a* 3, *a* 4) requires four strictly positive hyperparameters *a*_{1}, *a*_{2}, *a*_{3}, *a*_{4} for separate scaling of the parameters {w}_{I}^{i}, {b}_{I}^{i}, **w**_{
o
}, *b*_{
o
}. Hoff et al. [18] use the evidence framework for the adaptation of hyperparameters. This framework is introduced by MacKay [19] and is based on a Gaussian approximation of the posterior distribution of network weights. This evidence-based adaptation of the hyperparameters is incorporated into the network training and uses the same training points.

In order to minimize the objective function in equation 5, a scaled conjugate gradient scheme is used as implemented in the NETLAB toolbox [20]. The hyperparameters are all initially set to 0.001 and the weight and bias parameters are randomly initialized based on a standard normal distribution. The training scheme is iterated 50 times where each iteration consists of 50 gradient steps followed by two hyperparameter adaptation steps.

For example if we consider the 10% GC ranges, MGC computes 10 models using the training sequences from each GC range. Let *θ*_{
j
}, where *j* ∈ 1..10, denote the resulting neural network model for a given GC range *j*. Training the model *θ*_{
j
} is similar to training the single model *θ* as described above and using only the training examples that have GC-content within the GC range *j*. The network output for a given test sample **x**_{
i
} is computed as *f*(**x**_{
i
}; *θ*_{
j
}) = *P*_{
i
}, where the GC-content of the fragment that contains **x**_{
i
} is within the GC range *j*.