Skip to main content

Erratum to: MINE: Module Identification in Networks

The Original Article was published on 23 May 2011


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.

The primary difference is that as implemented, only the immediate neighborhood of each node is searched to identify initial clusters, and the merging process then facilitates cluster growth and removal of redundant clusters. This implementation results in accelerated cluster prediction relative to a more exhaustive search, which would perform comparably to a depth-first search across a larger portion of the network for each node. The published results and performance of MINE are unaffected; the description of the method, algorithm pseudocode, Fig. 1, and Additional file 1: Figure S1 have been updated to accurately reflect the implemented version of MINE.

Fig. 1
figure 1

Conceptual Overview of MINE Procedure


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 {Nv}, which we denote simply as Nv. The vertex weight (v w ) is the product of the maximal number of edges connected to any single node in Nv (k max ) and the density of Nv (d): v w = k max * d. Density is calculated as d = 2 e Nv /(V Nv * (V Nv - 1)), where V Nv is the number of vertices in Nv (i.e. v and its direct neighbors) and e Nv is the number of edges in Nv. A cluster (C) is then established by iterating through each vertex in Nv, 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 user-defined 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 user-defined 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 non-members (E out ): C mod = E in /E out . The process is performed for all vertices in Nv, 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 non-exclusive (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).


  1. 1.

    Vertex Weighting

    • procedure Vertex-Weighting

      • 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 Nv

        • d = density of Nv

        • v w = weight = k max * d

      • end for

    • end procedure

  2. 2.

    Cluster Prediction

    • procedure Cluster-Prediction

      • 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 modularity-score(Cn) > modularity-score(C) - modularity-score(C)*msp then

              add n to cluster C

          • else if modularity-score(Cn) > modularity-score(C) + modularity-score(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 modularity-score({C \v})

      • while ( sizeof(C) > 3 and (modularity-score({C \ v r }) > modularity-score(C) + modularity-score(C)*msp ) )

        • remove v r from C

        • v r = v that maximizes modularity-score({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 modularity-score

      • input: cluster: C

      • in = number of edges exclusively between members of C

      • out = number of edges exclusively between members and non-members of C

      • score = in/out

    • end procedure


  1. Rhrissorrakrai K, Gunsalus KC. MINE: Module Identification in Networks. BMC Bioinformatics. 2011;12:192.

    Article  PubMed  PubMed Central  Google Scholar 

Download references


We would like to thank Dan Kortschak from the University of Adelaide, who pointed out the discrepancy in our article to us.

Author information

Authors and Affiliations


Corresponding author

Correspondence to Kristin C. Gunsalus.

Additional information

The online version of the original article can be found under doi:10.1186/1471-2105-12-192.

Additional file

Additional file 1: Figure S1.

Expanded Conceptual Overview of MINE Procedure. The general procedure for the core MINE algorithm is presented with an example input network, vwp = 0.4 and msp = 0.9. The clustering procedure begins with the highest weighted node, where node weights are assigned as v w  = k max * d ( v w  = vertex weight, k max  = largest edge count within node’s local neighborhood, d = density ). Nodes are numbered in order visited. Current clusters (blue) are compared to candidate clusters (orange). A node is added to a growing cluster if it passes either of the following criteria: 1) its v w is within the specified range, or 2) the new cluster modularity (m) is within the specified range. The values of v w and m for current and candidate clusters are indicated below each illustrated step; a check mark (or “x”) is placed next to each value if addition of the new node passes (or fails) the corresponding test. After all possible candidate nodes are visited, the preliminary cluster is processed to remove singly-connected nodes and merged with existing clusters if amount of overlap meets the user-defined threshold. (PDF 338 kb)

Rights and permissions

Open Access This article is distributed under the terms of the Creative Commons Attribution 4.0 International License (, 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 ( applies to the data made available in this article, unless otherwise stated.

Reprints and permissions

About this article

Check for updates. Verify currency and authenticity via CrossMark

Cite this article

Rhrissorrakrai, K., Gunsalus, K.C. Erratum to: MINE: Module Identification in Networks. BMC Bioinformatics 17, 89 (2016).

Download citation

  • Received:

  • Accepted:

  • Published:

  • DOI: