GraphSAGE

Overview

GraphSAGE (SAmple and aggreGatE) is an inductive framework for learning node representations by sampling and aggregating features from a node's local neighborhood. Unlike transductive methods that must be retrained when new nodes join the graph, GraphSAGE learns aggregation functions that can generalize to unseen nodes.

GraphSAGE was proposed by W.L. Hamilton et al. of Stanford University in 2017:

• W.L. Hamilton, R. Ying, J. Leskovec, Inductive Representation Learning on Large Graphs (2017)

Concepts

Transductive and Inductive Framework

Most conventional graph embedding methods learn node embeddings by utilizing information from all nodes throughout the iterations. When new nodes are introduced to the network, the model must be retrained using the entire dataset. These transductive frameworks don't naturally generalize to unseen nodes.

GraphSAGE acts as an inductive framework. It trains aggregator functions rather than creating individual embeddings for each node. This allows embeddings for newly added nodes to be derived based on the features and structural details of existing nodes, eliminating the need to retrain.

GraphSAGE Process

This implementation uses a simplified version of GraphSAGE with random weight matrices. The number of layers is determined by the length of the sampleSizes list.

1. Initialize: Assign each node a random unit vector of size dimensions.
2. For each layer: For each node,
   • Sample: Randomly select sampleSizes[layer] of the node's direct neighbors (a neighbor may be selected more than once). Isolated nodes produce a zero aggregation vector.
   • Aggregate: Compute the element-wise mean of the sampled neighbors' current embeddings.
   • Concatenate: Concatenate the node's own embedding with the aggregated neighbor embedding, producing a vector of size 2 × dimensions.
   • Transform: Multiply the concatenated vector by a random weight matrix to project back to dimensions, then apply ReLU activation (sets all negative values to 0, keeps positive values unchanged).
   • Normalize: L2-normalize the resulting embedding.

Multi-hop neighborhood information propagates implicitly through the layers: after layer 0, each node's embedding already encodes its direct neighbors' information, so when layer 1 aggregates neighbors, it effectively captures 2-hop structure.

NOTE

The original paper trains the weight matrices and aggregator functions using SGD with a loss function that encourages nearby nodes to have similar embeddings. This simplified implementation uses random weight matrices instead, making it training-free while still capturing neighborhood structure through the sample-and-aggregate mechanism.

Considerations

• The GraphSAGE algorithm treats all edges as undirected, ignoring their original direction.

Example Graph

GQL
INSERT (A:default {_id: "A"}), (B:default {_id: "B"}),
       (C:default {_id: "C"}), (D:default {_id: "D"}),
       (E:default {_id: "E"}), (F:default {_id: "F"}),
       (G:default {_id: "G"}), (H:default {_id: "H"}),
       (I:default {_id: "I"}), (J:default {_id: "J"}),
       (K:default {_id: "K"}),
       (A)-[:default]->(B), (A)-[:default]->(C),
       (C)-[:default]->(D), (D)-[:default]->(C),
       (D)-[:default]->(F), (E)-[:default]->(C),
       (E)-[:default]->(F), (F)-[:default]->(G),
       (G)-[:default]->(J), (H)-[:default]->(G),
       (H)-[:default]->(I), (I)-[:default]->(I),
       (J)-[:default]->(G)

Parameters

Run Mode

Returns:

GQL
CALL algo.graphsage({
  dimensions: 10,
  sampleSizes: [5, 3]
}) YIELD nodeId, embedding

Result:

Stream Mode

Returns the same columns as run mode, streamed for memory efficiency.

GQL
CALL algo.graphsage.stream({
  dimensions: 10,
  sampleSizes: [5, 3, 2]
}) YIELD nodeId, embedding
RETURN nodeId, embedding

Result:

Stats Mode

Returns:

GQL
CALL algo.graphsage.stats({
  dimensions: 10,
  sampleSizes: [5, 3, 2]
}) YIELD nodeCount, dimensions

Result:

Write Mode

Computes results and writes them back to node properties. The write configuration is passed as a second argument map.

Write parameters:

Writable columns:

Returns:

GQL
CALL algo.graphsage.write({dimensions: 4}, {
  db: {
    property: "embedding"
  }
}) YIELD task_id, nodesWritten, computeTimeMs, writeTimeMs