Some more testing

Author: IoannisPanagiotas

algo/src/test/java/org/neo4j/gds/embeddings/node2vec/NegativeSampleProducerTest.java

@@ -19,20 +19,20 @@
  */
 package org.neo4j.gds.embeddings.node2vec;
 
+import org.assertj.core.data.Offset;
 import org.junit.jupiter.api.Test;
+import org.neo4j.gds.collections.ha.HugeLongArray;
 import org.neo4j.gds.core.concurrency.Concurrency;
 
-import java.util.Map;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-import java.util.stream.IntStream;
+import java.util.HashMap;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 class NegativeSampleProducerTest {
 
     @Test
     void shouldProduceSamplesAccordingToNodeDistribution() {
+
         var builder = new RandomWalkProbabilities.Builder(
             2,
             new Concurrency(4),
@@ -46,19 +46,40 @@ void shouldProduceSamplesAccordingToNodeDistribution() {
         builder.registerWalk(new long[]{1});
 
         RandomWalkProbabilities probabilityComputer = builder.build();
-
         var sampler = new NegativeSampleProducer(probabilityComputer.negativeSamplingDistribution(),0);
 
-        Map<Long, Integer> distribution = IntStream
-            .range(0, 1300)
-            .mapToObj(ignore -> sampler.next())
-            .collect(Collectors.toMap(
-                Function.identity(),
-                ignore -> 1,
-                Integer::sum
-            ));
+        var distribution  = new HashMap<Long,Integer>();
+        int SAMPLES  = 1300;
+        for (int i=0;i<SAMPLES;++i){
+            var next = sampler.next();
+            distribution.put(next,  distribution.getOrDefault(next,0) + 1);
+        }
 
         // We samples nodes with a probability of their number of occurrences^0.75 (16^0.75=12, 1^0.75=1)
-        assertEquals(1.0 / 12, distribution.get(1L).doubleValue() / distribution.get(0L), 0.1);
+        assertThat(distribution.get(1L).doubleValue() / distribution.get(0L)).isCloseTo(1.0/12, Offset.offset(0.1));
     }
+
+    @Test
+    void shouldProduceDifferentlyIfSeeded() {
+
+        var sampler1 = new NegativeSampleProducer(HugeLongArray.of(16,18),0);
+        var sampler2 = new NegativeSampleProducer(HugeLongArray.of(16,18),1);
+
+        var distribution1 = new HashMap<Long,Integer>();
+        var distribution2 = new HashMap<Long,Integer>();
+
+        int SAMPLES = 1300;
+        for (int i=0;i<SAMPLES;++i){
+            var next1 = sampler1.next();
+            distribution1.put(next1,  distribution1.getOrDefault(next1,0) + 1);
+            //
+            var next2 = sampler2.next();
+            distribution2.put(next2,  distribution1.getOrDefault(next2,0) + 1);
+        }
+
+        assertThat(distribution1.get(0L)).isNotEqualTo(distribution2.get(0L));
+        assertThat(distribution1.get(1L)).isNotEqualTo(distribution2.get(1L));
+
+    }
+
 }

algo/src/test/java/org/neo4j/gds/embeddings/node2vec/RandomWalkProbabilitiesTest.java

@@ -0,0 +1,71 @@
+/*
+ * Copyright (c) "Neo4j"
+ * Neo4j Sweden AB [http://neo4j.com]
+ *
+ * This file is part of Neo4j.
+ *
+ * Neo4j 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.
+ *
+ * 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.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.neo4j.gds.embeddings.node2vec;
+
+import org.assertj.core.data.Offset;
+import org.junit.jupiter.api.Test;
+import org.neo4j.gds.core.concurrency.Concurrency;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+ class RandomWalkProbabilitiesTest {
+
+    @Test
+    void shouldProduceSamplesAccordingToNodeDistribution() {
+        double positiveSamplingFactor = 0.001;
+        double negativeSamplingExponent = 0.75;
+        var builder = new RandomWalkProbabilities.Builder(
+            2,
+            new Concurrency(4),
+            positiveSamplingFactor,
+            negativeSamplingExponent
+        );
+
+        builder
+            .registerWalk(new long[]{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0});
+
+        builder.registerWalk(new long[]{1});
+
+        RandomWalkProbabilities probabilityComputer = builder.build();
+
+        var negSampling = probabilityComputer.negativeSamplingDistribution();
+        var posSampling = probabilityComputer.positiveSamplingProbabilities();
+
+        double app0 = 16;
+        double app1 = 1;
+        double sum = 17;
+        double freq0 = app0/sum;
+        double freq1 = app1/sum;
+
+        var expectedPos0 =   (Math.sqrt(freq0/positiveSamplingFactor) + 1) * (positiveSamplingFactor/freq0);
+        var expectedPos1 =   (Math.sqrt(freq1/positiveSamplingFactor) + 1) * (positiveSamplingFactor/freq1);
+
+        assertThat(posSampling.get(0)).isCloseTo(expectedPos0, Offset.offset(1e-6));
+        assertThat(posSampling.get(1)).isCloseTo(expectedPos1, Offset.offset(1e-6));
+
+        //neg[i] = 2*pow(16,negativeSamplingExponent) + neg[i-1]
+        long expectedNeg0 = 2 * (long) Math.pow(app0, negativeSamplingExponent);
+        long expectedNeg1 = 2 * (long) Math.pow(app1, negativeSamplingExponent) + expectedNeg0;
+
+        assertThat(negSampling.get(0)).isEqualTo(expectedNeg0);
+        assertThat(negSampling.get(1)).isEqualTo(expectedNeg1);
+
+    }
+}