DiffPool

DiffPool learns a soft cluster assignment matrix at each pooling layer, mapping nodes to a set of clusters in a fully differentiable manner. This allows the model to be trained end-to-end using gradient descent, unlike hard clustering methods.

• Assignment Matrix (S): Computed by a separate GNN, S = softmax(GNN_pool(A, X))
• Soft Membership: Each node belongs fractionally to multiple clusters, preserving gradient flow
• End-to-End Training: The pooling structure is optimized jointly with the downstream task loss
• Interpretation: The learned assignments reveal which nodes are grouped together, providing a natural hierarchical decomposition of the graph

At each pooling level, DiffPool generates a new, coarsened graph by aggregating node features and adjacency information according to the learned cluster assignments.

• New Feature Matrix: X' = S^T * Z, where Z is the node embeddings from the embedding GNN
• New Adjacency Matrix: A' = S^T * A * S, capturing the connectivity strength between clusters
• Multi-Resolution Representation: Successive pooling layers produce increasingly abstract graph summaries
• Interpretability Benefit: Each cluster in the coarsened graph represents a super-node whose function can be analyzed, enabling explanations at varying levels of graph granularity

To encourage the learned clusters to be structurally meaningful, DiffPool employs an auxiliary link prediction objective on the coarsened adjacency matrix.

• Objective: L_LP = ||A' - S^T * S||_F, minimizing the Frobenius norm between the coarsened adjacency and the inner product of assignments
• Intuition: Nodes assigned to the same cluster should have high connectivity; nodes in different clusters should have low connectivity
• Effect: This regularizer pushes the model to learn contiguous, community-like clusters rather than arbitrary groupings
• Interpretation: The resulting clusters correspond to functional modules or communities within the graph, making the pooling structure inherently explainable

DiffPool regularizes the entropy of the cluster assignment matrix to control the sharpness of the soft assignments and prevent degenerate solutions.

• Entropy Regularizer: L_E = - (1/n) * Σ Σ S_ij * log(S_ij), summed over all nodes and clusters
• Tunable Hyperparameter: A coefficient λ balances the entropy loss with the task loss
• High Entropy: Encourages more uniform, exploratory assignments
• Low Entropy: Pushes assignments toward near-one-hot, crisp cluster memberships
• Interpretation: By controlling assignment sharpness, practitioners can trade off between overlapping functional modules and discrete structural components in the explanation

The hierarchical nature of DiffPool enables the extraction of explanations at multiple scales, from fine-grained node importance to coarse module-level attributions.

• Layer 0 (Nodes): Original graph with individual node features
• Layer 1 (Subgraphs): First pooling layer clusters form interpretable motifs or functional groups
• Layer 2+ (Modules): Higher layers aggregate into system-level components
• Attribution Propagation: Importance scores from the final prediction can be propagated backward through the assignment matrices to assign relevance to original nodes
• Use Case: A molecular property prediction can be explained by identifying critical atoms (nodes), functional groups (Layer 1 clusters), and molecular fragments (Layer 2 clusters)

By pre-defining the number of clusters at each pooling layer, DiffPool maps variable-sized input graphs to a fixed-dimensional vector representation, which is essential for downstream classification tasks.

• Cluster Count (k): A hyperparameter specifying the number of clusters at each pooling level
• Permutation Invariance: The final graph-level embedding is invariant to node ordering
• Readout Function: After the final pooling layer, a readout (e.g., max or mean) produces a fixed-size embedding
• Interpretation: The fixed-size representation corresponds to a canonical decomposition of the graph into a set number of interpretable components, enabling consistent comparison across different input graphs