Touch up docs more

Co-authored-by: Brian Shi <[email protected]>

Author: breakanalysis

doc/modules/ROOT/pages/machine-learning/node-embeddings/hashgnn.adoc

@@ -35,14 +35,19 @@ For more information on this algorithm, see:
 
 === The algorithm
 
-The first step of the algorithm is optional and transforms input features into binary features.
-The HashGNN can only run on binary features, so this step is necessary.
-Then for a number of iterations, a new binary embedding is computed for each node using the embeddings of the previous iteration.
+The HashGNN algorithm can only run on binary features.
+There is an optional first step to transform input features into binary features.
+
+For a number of iterations, a new binary embedding is computed for each node using the embeddings of the previous iteration.
 In the first iteration, the previous embeddings are the binary feature vectors.
-Each node vector is constructed by taking `K` random samples.
+
+During one iteration, each node embedding vector is constructed by taking `K` random samples.
 The random sampling is carried out by successively selecting features with lowest min-hash values.
-In this selection, both features of the same node and of the neighbors of the node are considered.
-Hence, for each node, iteration and each `0 <= k < K` we sample a feature to add to the new embedding of the node, and we select either one of the node's own features or a feature from a neighbor.
+Features of each node itself and of its neighbours are both considered.
+
+There are three types of hash functions involved: 1) a function applied to a node's own features, 2) a function applied to a subset of neighbor's feature 3) a function applied to all neighbor's features to select the subset for hash function 2).
+For each iteration and sampling round `k<K` new hash functions are used, and the third function also varies by relationship type connecting to the neighbor.
+
 The sampling is consistent in the sense that if nodes `a` and `b` are same or similar in terms of their features, the features of their neighbors and the relationship types connecting the neighbors, the samples for `a` and `b` are also same or similar.
 The number `K` is called `embeddingDensity` in the configuration of the algorithm.
 The algorithm ends with another optional step that maps the binary embeddings to dense vectors.
@@ -57,7 +62,8 @@ The graph structure is `a--b--c`.
 We imagine running HashGNN for one iteration with `embeddingDensity=2`.
 
 During the first iteration and `k=0`, we compute an embedding for `(a)`.
-A hash value for `f1` turns out to be `7`. Since `(b)` is a neighbor, we generate a value for its feature `f2` and it becomes `11`.
+A hash value for `f1` turns out to be `7`.
+Since `(b)` is a neighbor, we generate a value for its feature `f2` and it becomes `11`.
 The value `7` is sampled from a hash function which we call "one" and `11` from a hash function "two".
 Thus `f1` is added to the new features for `(a)` since it has a smaller hash value.
 We repeat for `k=1` and this time the hash values are `4` and `2`, so now `f2` is added as a feature to `(a)`.
@@ -74,7 +80,10 @@ We proceed similarily with `k=1` and `f1` is selected again.
 Since the embeddings consist of binary features, this second addition has no effect.
 
 We omit the details of computing the embedding of `(c)`.
-Our result is that `(a)` has features `f1` and `f2` and `(b)` has only the feature `f1`.
+
+After the 2 sampling rounds, the iteration is complete and since there is only one iteration, we are done.
+Each node has a binary embedding that contains some subset of the original binary features.
+In particular, `(a)` has features `f1` and `f2`, `(b)` has only the feature `f1`.
 
 === Features