Visualization of Graph Neural Networks

Have you ever found it challenging to represent a graph from a very large dataset while building a graph neural network model?

This article presents a method to sample and visualize a subgraph from such datasets.

🎯 Introduction
🎨 NetworkX library
      Overview
      Sampling large graphs
      Implementation
      Layouts
      Graph representation
      Comparing layouts
📘 References
💡 Appendix        

What you will learn: How to sample and visualize a graph from a very large dataset for modeling graph neural networks.

Notes: 

• Environments: python 3.12.5,  matplotlib 3.9, numpy 2.2.0, torch 2.5.1, torch-geometric 2.6.1, networkx 3.4.2
• Source code is available on GitHub [ref 1]
• To enhance the readability of the algorithm implementations, we have omitted non-essential code elements like error checking, comments, exceptions, validation of class and method arguments, scoping qualifiers, and import statement.

✅ Please subscribe to Hands-on Geometric Deep Learning for in-depth topics on Geometric learning, reviews and exercises.

🎯 Introduction

This article focuses on visualizing subgraphs within the context of graph neural networks. It does not cover the introduction or explanation of graph neural network architectures and models, as those topics are beyond its scope [ref 2, 3].

📌 There are several Python libraries available for analyzing and visualizing graphs, including Plotly, PyVis, and NetworkKit. In some of our future articles on graph neural networks and geometric deep learning, we will use NetworkX for visualization.

As a reminder, a graph data is fully defined by an instance of Data of 'torch_geometric.data' package with the following property

• data.x: Node feature matrix with shape num_nodes x num_node_features            
• data.edge_index: Graph connectivity with shape 2 x num_edges and type torch.Long
• data.edge_attr: Edge feature matrix shape: num_edges x num_edge_features        
• data.y: Target to train against (may have arbitrary shape), e.g., node-level targets of shape [num_nodes, ] or graph-level targets of shape [1, ]
• data.pos: Node position matrix with shape num_nodes x num_dimensions 

🎨 NetworkX library

Overview

NetworkX is a BSD-license powerful and flexible Python library for the creation, manipulation, and analysis of complex networks and graphs. It supports various types of graphs, including undirected, directed, and multi-graphs, allowing users to model relationships and structures efficiently [ref 4]

NetworkX provides a wide range of algorithms for graph theory and network analysis, such as shortest paths, clustering, centrality measures, and more. It is designed to handle graphs with millions of nodes and edges, making it suitable for applications in social networks, biology, transportation systems, and other domains. With its intuitive API and rich visualization capabilities, NetworkX is an essential tool for researchers and developers working with network data.

The library supports many standard graph algorithms such as clustering, link analysis, minimum spanning tree, shortest path, cliques, coloring, cuts, Erdos-Renyi or graph polynomial.

Sampling large graphs

Most datasets included in the PyG library contain an extremely large number of nodes and edges, making them impractical to visualize directly. To address this, we can extract (or sample) one or more subgraphs that are easier to display.

In our design, a subgraph is derived from the original large graph by sampling its nodes and edges based on a specified range of indices, as shown below:

In the illustration above, the sampled nodes are [12, ...., 19]

Implementation

For the sake of simplicity, let wraps the visualization of a graph neural network data into a class GNNPlotter which constructor takes 3 parameters [ref 4]:

• graph: Reference to NetworkX directed or undirected graph
• data: Data representation of the graph dataset
• samples_node_index_range: Tuple (index of first sampled node, index of last sampled node) 

Simplified constructor for directed (build) and undirected graph (build_directed) are also provided.

Let’s first review our implementation for sampling graph vertices and edges, which involves the following steps:

1. Transpose the list of edge indices.
2. If a range for sampling indices is defined, use it to extract the indices of the first node, sampled_node_index_range[0], and the last node, 
3. ,  in the subgraph.
4. Add the edge indices associated with the selected nodes.

Finally, the visualization of the graph is achieved by drawing it with the draw method and overlaying the edges using draw_networkx_edges.

In our basic application, we define the layout, customize the color and size of the nodes, and set the title for the display.

Layouts

NetworkX provides several graph layouts to visually display undirected graphs. Each layout arranges nodes in a specific pattern, suited to different types of graphs and visualization purposes. Here's a brief overview of the common layouts available in networkx [ref 4]

1. Spring Layout: Positions nodes using a force-directed algorithm. Nodes repel each other, while edges act as springs pulling connected nodes closer.
2. Circular Layout: Arranges nodes uniformly on a circle.
3. Shell Layout: Arranges nodes in concentric circles (shells). Useful for graphs with hierarchical structures.
4. Planar Layout: Positions nodes to ensure no edges overlap, provided the graph is planar.
5. Kamada-Kawai Layout: Positions nodes to minimize the "energy" of the graph. Produces aesthetically pleasing layouts similar to spring_layout.
6. Spectral Layout: Positions nodes using the eigenvectors of the graph Laplacian. Captures graph structure in the arrangement.
7. Random Layout: Places nodes randomly within a unit square.
8. Spiral Layout: Positions nodes in a spiral pattern.

Graph representation

Let's consider the Flickr data set included in Torch Geometric (PyG) described in [ref 5]. As a reminder, The Flickr dataset is a graph where nodes represent images and edges signify similarities between them [ref 6]. It includes 89,250 images and 899,756 relationships. Node features consist of image descriptions and shared properties.

Let's apply the class GNNPlotter methods to the Flickr data set, selecting the edges for nodes of index starting 12 to 21 included, using the spring layout.

Output: 319

The 319 vertices of the Flickr graph data set and its undirected edges are visualized using the spring layout. The visualization covers 319/89,250 = 0.35% of the entire dataset of images.

Comparing layouts

Undirected graph representation

Let’s demonstrate six common layouts for displaying subgraphs sampled from the Flickr dataset using 67 nodes.

Directed graph representation

Finally, let’s apply the same layout to a directed graph derived from the Flickr dataset.

✅ Thanks for reading. For comprehensive topics on geometric learning, including detailed analysis, reviews and exercises, subscribe to Hands-on Geometric Deep Learning

📘 References

1.  github.com/patnicolas/geometriclearning/python/dl
2.  A Practical Tutorial on Graph Neural Networks
3. Modeling Graph Neural Networks With PyG
4.  networkx.org
5.  Torch-geometric Flickr dataset API
6.  Modeling Graph Neural Networks With PyG - Flickr dataset

Patrick Nicolas has over 25 years of experience in software and data engineering, architecture design and end-to-end deployment and support with extensive knowledge in machine learning. He has been director of data engineering at Aideo Technologies since 2017 and he is the author of "Scala for Machine Learning", Packt Publishing ISBN 978-1-78712-238-3 and Hands-on Geometric Deep Learning newsletter.

💡 Appendix

A selection of edge indices in the range [10, 28] edges indices produces the graph with 1057 nodes and 1.191% coverage.

A selection of edge indices in the range [10, 21] edges indices produces the graph with 351 nodes and 0.039% coverage.

A selection of edge indices in the range [10, 15] edges indices produces the graph with 80 nodes and 0.008% coverage.

#GeometricDeepLearning #GraphNeuralNetwork #PyTorchGeometric #NetworkX