I’ve been watching how neural networks learn from images, text, and sequences. It’s incredible. But there’s a whole other world of data they were missing for a long time: the data that’s all about connections. Think about a social network. It’s not just the profile pictures and posts; it’s the web of friendships, follows, and likes that tells the real story. How do we build models that understand not just the things, but the relationships between them?

That question brought me to Graph Neural Networks. I realized that to move beyond standard grids and sequences, we had to teach models to see the network. The result is a powerful way to predict things in systems ranging from molecular biology to recommendation engines. Let’s build one together.

First, we need to understand our material. A graph is just a collection of points (nodes) connected by lines (edges). Each node might have features, like a user’s age or a molecule’s atom type. The magic of a GNN is in its neighborhood walk. It lets each node gather information from its connected neighbors, mixing their features to build a richer understanding of its own place in the network.

So, how do we actually code this? Let’s set up our workshop.

pip install torch torch-geometric

Now, let’s grab a classic dataset to experiment with. The Cora citation network is a great starting point. It’s a graph of academic papers (nodes) connected by citations (edges). Each paper has a bag-of-words feature vector, and our job is to classify them into topics.

from torch_geometric.datasets import Planetoid

dataset = Planetoid(root='/tmp/Cora', name='Cora')
data = dataset[0]
print(f'We have {data.num_nodes} papers and {data.num_edges} citations.')

You’ll see we have thousands of nodes. But where are the explicit instructions for the model about which nodes are connected? The edge_index is the key. It’s not an image; it’s a list of connections. This is what makes graph data different.

Now, for the brain of our operation. We’ll build a simple Graph Convolutional Network. Don’t let the name intimidate you. At its heart, it’s a clever way for a node to average features from its neighbors and itself, then pass that through a learnable layer.

import torch
import torch.nn.functional as F
from torch_geometric.nn import GCNConv

class SimpleGCN(torch.nn.Module):
    def __init__(self, num_features, hidden_channels, num_classes):
        super().__init__()
        self.conv1 = GCNConv(num_features, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, num_classes)

    def forward(self, data):
        x, edge_index = data.x, data.edge_index
        x = self.conv1(x, edge_index)
        x = F.relu(x)
        x = F.dropout(x, p=0.5, training=self.training)
        x = self.conv2(x, edge_index)
        return F.log_softmax(x, dim=1)

See? It looks familiar, like any other neural network, but the layers need the connection list edge_index to do their job. The model learns how to blend information across the graph’s structure.

But classification is only half the story. What if we want to predict new connections? This is link prediction. It’s the engine behind “people you may know” suggestions. The idea is to score how likely an edge is to exist between two nodes. We train it by showing the model real edges and some fake, non-existent ones.

from torch_geometric.nn import GAE
from torch_geometric.nn import GCNConv

class GCNEncoder(torch.nn.Module):
    def __init__(self, in_channels, out_channels):
        super().__init__()
        self.conv1 = GCNConv(in_channels, 2 * out_channels)
        self.conv2 = GCNConv(2 * out_channels, out_channels)

    def forward(self, x, edge_index):
        x = self.conv1(x, edge_index).relu()
        return self.conv2(x, edge_index)

# Initialize the Graph Autoencoder for link prediction
model = GAE(GCNEncoder(dataset.num_features, 64))

Here, the encoder creates a compressed representation for each node. The “decoder” is simple: it calculates a score for a potential link, often just using the dot product of two node representations. A high score means the model thinks a link should exist.

Training these models requires care. You can’t just shuffle nodes randomly for a train/test split because they’re connected. For node classification, we mask specific nodes. For link prediction, we must hide some edges during training and try to predict them later.

# Node Classification Split (already in the Cora dataset)
data.train_mask = ... # Boolean mask for training nodes
data.val_mask = ...   # Boolean mask for validation nodes

# Link Prediction Split (more manual)
from torch_geometric.utils import train_test_split_edges
data = train_test_split_edges(data)  # Splits edges into train/val/test sets

Why go through this trouble? Because the real world is full of graphs. From predicting protein interactions in biology to detecting fraudulent accounts in finance, modeling relationships unlocks new possibilities. A recommendation system can be framed as a link prediction problem on a user-item graph. Suddenly, the model isn’t just looking at individual purchases; it’s seeing the whole community of similar users.

As you experiment, you’ll hit questions. What if my graph is enormous, with millions of nodes? You’ll use techniques like neighborhood sampling, where for each batch, you only load a node’s local neighborhood. What if some connections are more important than others? You might try a Graph Attention Network (GAT), which lets nodes weigh their neighbors’ influence. The journey from a simple GCN to these advanced models is a natural progression.

Building with GNNs feels like giving your model a new sense. It’s the sense of context, of place within a system. The code is just the start. The real reward is in designing systems that understand the networked nature of everything from physics to social systems. What kind of connected data have you encountered?

I hope this guide helps you start your own project. If you’ve built something interesting or have questions about handling a specific type of graph data, let me know in the comments. Sharing what you learn helps everyone build better, more intelligent systems. Feel free to like and share this if it helped you see data in a new, connected way.

---

As a best-selling author, I invite you to explore my books on Amazon. Don’t forget to follow me on Medium and show your support. Thank you! Your support means the world!

---

101 Books

101 Books is an AI-driven publishing company co-founded by author Aarav Joshi. By leveraging advanced AI technology, we keep our publishing costs incredibly low—some books are priced as low as $4—making quality knowledge accessible to everyone.

Check out our book Golang Clean Code available on Amazon.

Stay tuned for updates and exciting news. When shopping for books, search for Aarav Joshi to find more of our titles. Use the provided link to enjoy special discounts!

---

📘 Checkout my latest ebook for free on my channel!
Be sure to like, share, comment, and subscribe to the channel!

---

Our Creations

Be sure to check out our creations:

Investor Central | Investor Central Spanish | Investor Central German | Smart Living | Epochs & Echoes | Puzzling Mysteries | Hindutva | Elite Dev | JS Schools

---

We are on Medium

Tech Koala Insights | Epochs & Echoes World | Investor Central Medium | Puzzling Mysteries Medium | Science & Epochs Medium | Modern Hindutva