Apply degree normalization to property part of initial random vectors

A seemingly strange/buggy behavior was reported.
Somewhat simplified, it was expected that when
nodeSelfInfluence > 0 and propertyRatio is high (0.8),
that among (n1: {val: [0.1, 1.0]}), (n2: {val: [0.1, 1.0]}) and (n3: {val: [0.2, 1.0]},
it should "often" hold that SIM(emb(n1), emb(n2)) > SIM(emb(n1), emb(n3).

Whether this expectation is reasonable is out of the scope of this commit, but
to partly remedy this, something else was discovered and fixed:

The initial random vector is split into two segments corresponding to
embeddingDimension = baseEmbeddingDimension + propertyDimension.
The the first segment, entries were scaled by the degree of the node to the power of
`normalizationStrength`, however, the second segment of length propertyDimension was
not scaled by this scaling factor.
The current commit applies the scaling also to the second segment.
This removes the effect of reduced influence of entries in the second segment, that is
reduced node property influence, when normalizationStrength > 0 and deg(n) > 1.

Author: breakanalysis

algo/src/main/java/org/neo4j/gds/embeddings/fastrp/FastRP.java

@@ -344,37 +344,42 @@ public void run() {
 
                 float entryValue = scaling * sqrtSparsity / sqrtEmbeddingDimension;
                 random.reseed(randomSeed ^ graph.toOriginalNodeId(nodeId));
-                var randomVector = computeRandomVector(nodeId, random, entryValue);
+                var randomVector = computeRandomVector(nodeId, random, entryValue, scaling);
                 embeddingB.set(nodeId, randomVector);
                 embeddingA.set(nodeId, new float[embeddingDimension]);
             });
             progressTracker.logProgress(partition.nodeCount());
         }
 
-        private float[] computeRandomVector(long nodeId, Random random, float entryValue) {
+        private float[] computeRandomVector(long nodeId, Random random, float entryValue, float scaling) {
             var randomVector = new float[embeddingDimension];
             for (int i = 0; i < baseEmbeddingDimension; i++) {
                 randomVector[i] = computeRandomEntry(random, entryValue);
             }
 
             propertyVectorAdder.setRandomVector(randomVector);
+            propertyVectorAdder.setScaling(scaling);
             FeatureExtraction.extract(nodeId, -1, featureExtractors, propertyVectorAdder);
 
             return randomVector;
         }
 
         private class PropertyVectorAdder implements FeatureConsumer {
             private float[] randomVector;
+            private float scaling = 1.0f;
 
             void setRandomVector(float[] randomVector) {
                 this.randomVector = randomVector;
             }
+            void setScaling(float scaling) {
+                this.scaling = scaling;
+            }
 
             @Override
             public void acceptScalar(long ignored, int offset, double value) {
                 float floatValue = (float) value;
                 for (int i = baseEmbeddingDimension; i < embeddingDimension; i++) {
-                    randomVector[i] += floatValue * propertyVectors[offset][i - baseEmbeddingDimension];
+                    randomVector[i] += scaling * floatValue * propertyVectors[offset][i - baseEmbeddingDimension];
                 }
             }
 
@@ -384,7 +389,7 @@ public void acceptArray(long ignored, int offset, double[] values) {
                     var value = (float) values[j];
                     float[] propertyVector = propertyVectors[offset + j];
                     for (int i = baseEmbeddingDimension; i < embeddingDimension; i++) {
-                        randomVector[i] += value * propertyVector[i - baseEmbeddingDimension];
+                        randomVector[i] += scaling * value * propertyVector[i - baseEmbeddingDimension];
                     }
                 }
             }