Erratum to: MINE: Module Identification in Networks
 Kahn Rhrissorrakrai^{1} and
 Kristin C. Gunsalus^{2}Email author
https://doi.org/10.1186/s1285901609295
© Rhrissorrakrai and Gunsalus. 2016
Received: 1 February 2016
Accepted: 1 February 2016
Published: 17 February 2016
The original article was published in BMC Bioinformatics 2011 12:4581
Erratum
It was brought to our attention that there was a discrepancy between the description and implementation of the MINE algorithm in our article [1]. We regret any inconvenience that may have resulted from this inaccuracy.
Scoring
MINE receives as input any number of interaction files. The network is treated as an undirected, unweighted graph. Each vertex v in the graph G = (V, E) is then weighted based upon its local neighborhood N, defined as the set all vertices connected directly to v (at a depth of 1); we call the set N inclusive of v itself {N∪v}, which we denote simply as N∪v. The vertex weight (v _{ w }) is the product of the maximal number of edges connected to any single node in N∪v (k _{ max }) and the density of N∪v (d): v _{ w } = k _{ max } * d. Density is calculated as d = 2 e _{ N∪v }/(V _{ N∪v } * (V _{ N∪v }  1)), where V _{ N∪v } is the number of vertices in N∪v (i.e. v and its direct neighbors) and e _{ N∪v } is the number of edges in N∪v. A cluster (C) is then established by iterating through each vertex in N∪v, in order of highest to lowest weight, and adding neighbors if either of two criteria are satisfied: A) the neighbor vertex weight is above a minimum threshold (as determined by the userdefined vertex weight percentage (vwp) of the seed vertex) and does not decrease the cluster modularity score (by an amount equal to or greater than the userdefined modularity score percentage (msp)); B) the modularity score for the cluster is improved by msp. Cluster modularity (C _{ mod }) is defined as the ratio of edges between nodes of a cluster (E _{ in }) and edges between cluster members and nonmembers (E _{ out }): C _{ mod } = E _{ in } /E _{ out }. The process is performed for all vertices in N∪v, and the resulting cluster can be optionally refined by removing all vertices with k = 1 (if the flag Trim is set). By default, clusters are nonexclusive (i.e. members are allowed to participate in several clusters); a new cluster will be merged with any existing cluster if their vertices overlap by >50 %, otherwise it will be stored as a new cluster. Each (new or merged) cluster is then scored (C _{ s }) as the product of its density (d) and the number of members in the cluster (V _{ C }): C _{ s } = d * V _{ C }. The cluster identification process is repeated for each vertex in V in order of descending v _{ w }. The final set of clusters is evaluated for improvements in modularity scores when individual members are excluded, and the membership of each cluster is updated accordingly (by removing nodes from a cluster if the modularity score increases by more than msp in its absence).
Algorithm
 1.Vertex Weighting

procedure VertexWeighting

input: graph: G = (V,E)

for all v in G

N = set of immediate neighbors of v (depth = 1)

k _{ max } = maximum number of edges from any one vertex in set N∪v

d = density of N∪v

v _{ w } = weight = k _{ max } * d


end for


end procedure

 2.Cluster Prediction

procedure ClusterPrediction

input: graph: G = (V,E); vertex weight: v _{ w }; vertex weight percentage: vwp; modularity score

percentage: msp; merge percentage: mp


for v ∈ V _{ w } (from high → low weight)

N = set of immediate neighbors of n (depth = 1)

push (tocheck, v )

push (tocheck, N )

for n ∈ tocheck

if v _{ w } of n ≥ (v _{ w } of v)(1 – vwp) then

if modularityscore(C∪n) > modularityscore(C)  modularityscore(C)*msp then
add n to cluster C


else if modularityscore(C∪n) > modularityscore(C) + modularityscore(C)*msp

add n to cluster C


end if


end for

if trim == true then call: Trim (C)

if percent overlap C with existing cluster(s) ≥ mp

Merge(C) with existing cluster(s)


C _{ score } = density(C) * sizeof(C)


end for

for C ∈ AllClusters

ModularityCleanup(C)


ends for


end procedure

procedure ModularityCleanup

input: cluster: C

v _{ r } = v that maximizes modularityscore({C \v})

while ( sizeof(C) > 3 and (modularityscore({C \ v _{ r } }) > modularityscore(C) + modularityscore(C)*msp ) )

remove v _{ r } from C

v _{ r } = v that maximizes modularityscore({C \v})


end while


end procedure

procedure Trim

input: cluster: C

for all v in C

if k of v < 2 then remove v from C


end for


end procedure

procedure modularityscore

input: cluster: C

in = number of edges exclusively between members of C

out = number of edges exclusively between members and nonmembers of C

score = in/out


end procedure

Notes
Declarations
Acknowledgement
We would like to thank Dan Kortschak from the University of Adelaide, who pointed out the discrepancy in our article to us.
Open AccessThis article is distributed under the terms of the Creative Commons Attribution 4.0 International License (http://creativecommons.org/licenses/by/4.0/), which permits unrestricted use, distribution, and reproduction in any medium, provided you give appropriate credit to the original author(s) and the source, provide a link to the Creative Commons license, and indicate if changes were made. The Creative Commons Public Domain Dedication waiver (http://creativecommons.org/publicdomain/zero/1.0/) applies to the data made available in this article, unless otherwise stated.
Authors’ Affiliations
Reference
 Rhrissorrakrai K, Gunsalus KC. MINE: Module Identification in Networks. BMC Bioinformatics. 2011;12:192.View ArticlePubMedPubMed CentralGoogle Scholar