3.4 return modularities louvain (#799)

* modularities

* fix batching of writes with low node count

* formatting

Author: mneedham

algo/src/main/java/org/neo4j/graphalgo/LouvainProc.java

@@ -102,7 +102,10 @@ public Stream<LouvainResult> louvain(
             } else {
                 louvain.compute(configuration.getIterations(10), configuration.get("innerIterations", 10));
             }
-            builder.withIterations(louvain.getLevel()).withCommunityCount(louvain.getCommunityCount());
+            builder.withIterations(louvain.getLevel())
+                    .withCommunityCount(louvain.getCommunityCount())
+                    .withModularities(louvain.getModularities())
+                    .withFinalModularity(louvain.getFinalModularity());
         }
 
         if (configuration.isWriteFlag()) {

algo/src/main/java/org/neo4j/graphalgo/impl/louvain/Louvain.java

@@ -60,6 +60,7 @@ public class Louvain extends Algorithm<Louvain> {
     private ProgressLogger progressLogger;
     private TerminationFlag terminationFlag;
     private int[] communities;
+    private double[] modularities;
     private int[][] dendrogram;
     private double[] nodeWeights;
     private Graph root;
@@ -86,6 +87,7 @@ public Louvain compute(int maxLevel, int maxIterations) {
         Graph graph = this.root;
         // result arrays
         dendrogram = new int[maxLevel][];
+        modularities = new double[maxLevel];
         int nodeCount = rootNodeCount;
         for (level = 0; level < maxLevel; level++) {
             // start modularity optimization
@@ -112,6 +114,7 @@ public Louvain compute(int maxLevel, int maxIterations) {
             }
             nodeCount = communityCount;
             dendrogram[level] = rebuildCommunityStructure(communityIds);
+            modularities[level] = modularityOptimization.getModularity();
             graph = rebuildGraph(graph, communityIds, communityCount);
         }
         dendrogram = Arrays.copyOf(dendrogram, level);
@@ -132,6 +135,7 @@ public Louvain compute(WeightMapping communityMap, int maxLevel, int maxIteratio
         Graph graph = rebuildGraph(this.root, communities, nodeCount);
         // result arrays
         dendrogram = new int[maxLevel][];
+        modularities = new double[maxLevel];
 
         for (level = 0; level < maxLevel; level++) {
             // start modularity optimization
@@ -158,6 +162,7 @@ public Louvain compute(WeightMapping communityMap, int maxLevel, int maxIteratio
             }
             nodeCount = communityCount;
             dendrogram[level] = rebuildCommunityStructure(communityIds);
+            modularities[level] = modularityOptimization.getModularity();
             graph = rebuildGraph(graph, communityIds, communityCount);
         }
         dendrogram = Arrays.copyOf(dendrogram, level);
@@ -232,6 +237,14 @@ public int[][] getDendrogram() {
         return dendrogram;
     }
 
+    public double[] getModularities() {
+        return Arrays.copyOfRange(modularities, 0, level);
+    }
+
+    public double getFinalModularity() {
+        return modularities[level-1];
+    }
+
     /**
      * number of outer iterations
      *

algo/src/main/java/org/neo4j/graphalgo/impl/louvain/LouvainCommunityExporter.java

@@ -1,18 +1,18 @@
 /**
  * Copyright (c) 2017 "Neo4j, Inc." <http://neo4j.com>
- *
+ * <p>
  * This file is part of Neo4j Graph Algorithms <http://github.com/neo4j-contrib/neo4j-graph-algorithms>.
- *
+ * <p>
  * Neo4j Graph Algorithms is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation, either version 3 of the License, or
  * (at your option) any later version.
- *
+ * <p>
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
- *
+ * <p>
  * You should have received a copy of the GNU General Public License
  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
@@ -93,7 +93,7 @@ public void run() {
         private void writeEverything() {
             acceptInTransaction(statement -> {
                 final Write dataWriteOperations = statement.dataWrite();
-                for(PrimitiveIntIterator it = iterable.iterator(); it.hasNext(); ) {
+                for (PrimitiveIntIterator it = iterable.iterator(); it.hasNext(); ) {
                     final int id = it.next();
                     // build int array
                     final int[] data = new int[allCommunities.length];
@@ -121,7 +121,7 @@ private void writeEverything() {
         private void onlyWriteFinalCommunities() {
             acceptInTransaction(statement -> {
                 final Write dataWriteOperations = statement.dataWrite();
-                for(PrimitiveIntIterator it = iterable.iterator(); it.hasNext(); ) {
+                for (PrimitiveIntIterator it = iterable.iterator(); it.hasNext(); ) {
                     final int id = it.next();
 
                     dataWriteOperations.nodeSetProperty(

algo/src/main/java/org/neo4j/graphalgo/results/LouvainResult.java

@@ -18,6 +18,9 @@
  */
 package org.neo4j.graphalgo.results;
 
+import java.util.ArrayList;
+import java.util.List;
+
 /**
  * @author mknblch
  */
@@ -29,14 +32,23 @@ public class LouvainResult {
     public final long nodes;
     public final long iterations;
     public final long communityCount;
+    public final List<Double> modularities;
+    public final double modularity;
 
-    private LouvainResult(long loadMillis, long computeMillis, long writeMillis, long nodes, long iterations, long communityCount) {
+    private LouvainResult(long loadMillis, long computeMillis, long writeMillis, long nodes, long iterations,
+                          long communityCount, double[] modularities, double modularity) {
         this.loadMillis = loadMillis;
         this.computeMillis = computeMillis;
         this.writeMillis = writeMillis;
         this.nodes = nodes;
         this.iterations = iterations;
         this.communityCount = communityCount;
+
+        this.modularities = new ArrayList<>(modularities.length);
+        for (double mod : modularities) this.modularities.add(mod);
+
+
+        this.modularity = modularity;
     }
 
     public static Builder builder() {
@@ -48,6 +60,8 @@ public static class Builder extends AbstractResultBuilder<LouvainResult> {
         private long nodes = 0;
         private long communityCount = 0;
         private long iterations = 1;
+        private double[] modularities = new double[]{};
+        private double modularity = -1.0;
 
         public Builder withIterations(long iterations) {
             this.iterations = iterations;
@@ -64,8 +78,19 @@ public Builder withNodeCount(long nodes) {
             return this;
         }
 
+        public Builder withModularities(double[] modularities) {
+            this.modularities = modularities;
+            return this;
+        }
+
+        public Builder withFinalModularity(double modularity) {
+            this.modularity = modularity;
+            return this;
+        }
+
         public LouvainResult build() {
-            return new LouvainResult(loadDuration, evalDuration, writeDuration, nodes, iterations, communityCount);
+            return new LouvainResult(loadDuration, evalDuration, writeDuration, nodes, iterations, communityCount,
+                    modularities, modularity);
         }
     }
 }

core/src/main/java/org/neo4j/graphalgo/core/utils/ParallelUtil.java

@@ -53,7 +53,7 @@ public static Collection<PrimitiveIntIterable> batchIterables(int concurrency, i
         if (concurrency <= 0) {
             throw new IllegalArgumentException("concurrency must be > 0");
         }
-        final int batchSize = nodeCount / concurrency;
+        final int batchSize = Math.max(1, nodeCount / concurrency);
         int numberOfBatches = ParallelUtil.threadSize(batchSize, nodeCount);
         if (numberOfBatches == 1) {
             return Collections.singleton(new IdMap.IdIterable(0, nodeCount));

tests/src/test/java/org/neo4j/graphalgo/impl/LouvainMultiLevelTest.java

@@ -140,5 +140,7 @@ public void testComplex() throws Exception {
 
         assertArrayEquals(new int[]{0, 0, 0, 1, 1, 1, 2, 2, 2}, dendogram[0]);
         assertArrayEquals(new int[]{0, 0, 0, 1, 1, 1, 2, 2, 2}, algorithm.getCommunityIds());
+        assertEquals(0.53, algorithm.getFinalModularity(), 0.01);
+        assertArrayEquals(new double[]{0.53}, algorithm.getModularities(), 0.01);
     }
 }