Getting Started with GNN Implementation: A Practical PyTorch Geometric Guide

Some links on this page are affiliate links: if you buy through them we may earn a commission, at no extra cost to you.

Analytics Vidhya’s “Getting Started with GNN Implementation”, by Ketan Kumar and last updated March 31, 2024, is a broad introduction to graph neural networks (GNNs). It covers graph concepts, message passing, GCNs, GATs, pooling, and examples using NetworkX and PyTorch Geometric. It is a useful starting point, but its PyTorch 1.9.0/CUDA 11.1 installation command is tied to an older environment; check the current PyTorch Geometric installation instructions against your Python, PyTorch, CUDA, and operating-system versions before using it.

This guide follows the tutorial’s path while making the implementation choices explicit: what to represent as a graph, how to encode it, how to train a small node classifier, and how to evaluate it without confusing a benchmark demonstration for production evidence.

#	Preview	Product	Price
1		Hands-On Machine Learning with Scikit-Learn and PyTorch: Concepts, Tools, and Techniques to Build...	$77.72	Buy on Amazon
2		Machine Learning with PyTorch and Scikit-Learn: Develop machine learning and deep learning models...	$34.23	Buy on Amazon
3		Deep Learning with PyTorch, Second Edition: Training and applying deep learning and generative AI...	$51.68	Buy on Amazon
4		Mastering PyTorch: Create and deploy deep learning models from CNNs to multimodal models, LLMs, and...	$34.58	Buy on Amazon
5		The Hundred-Page Language Models Book: hands-on with PyTorch (The Hundred-Page Books)	$46.95	Buy on Amazon

What a GNN does—and when you need one

A graph neural network learns from entities and their relationships. A conventional image model receives a grid, and a sequence model receives an ordered series. A graph has neither a fixed grid nor a single natural sequence: each node may have a different number of neighbors, and node identifiers do not carry an inherent ordering. GNN layers combine a node’s features with information from connected nodes while respecting that structure.

This does not mean ordinary neural networks cannot be applied to graph-derived data. It means they do not natively account for arbitrary connectivity and the fact that renumbering nodes should not change the underlying problem. A GNN is worth testing when edges encode relevant information—such as interactions, citations, transactions, or molecular bonds—and when that information is available at prediction time.

#1 Best Overall

Sale

Hands-On Machine Learning with Scikit-Learn and PyTorch: Concepts, Tools, and Techniques to Build Intelligent Systems

$77.72

Buy on Amazon

• Good candidates: user–item interactions, transaction networks, citation networks, molecules, knowledge graphs, roads, and protein-interaction networks.
• Question the graph first: if edges are arbitrary, noisy, created from future events, or unrelated to the target, message passing can add cost without useful signal.
• Compare with simpler models: a majority-class predictor, a feature-only classifier, logistic regression, gradient-boosted trees, matrix factorization, or classical graph algorithms may be stronger or easier to deploy.

The Analytics Vidhya tutorial introduces applications including fraud detection, recommendations, and drug discovery. Those are possible uses, not evidence that a GNN will outperform a non-graph baseline on a particular dataset.

Represent the problem as a graph

A graph is written as G = (V, E), where V is a set of nodes and E is a set of relationships between them. A learning problem may also include node features X ∈ R^(|V| × F), edge attributes, labels on nodes or edges, or a label for each whole graph.

Before coding, decide what an edge means and whether its direction matters. A graph that records “account A paid account B” is not automatically equivalent to an undirected friendship network. Likewise, an edge should not encode information that would be unavailable when the model is used.

Graph properties that change the modeling choice

• Directed or undirected: in a directed graph, source and destination have distinct roles. An undirected relationship is often represented by message routes in both directions.
• Weighted or unweighted: an edge may carry a strength, count, distance, or other attribute. Include it only if the chosen model uses it appropriately.
• Homogeneous or heterogeneous: a homogeneous graph has one node and edge type; a heterogeneous graph can connect different kinds of entities through different relationship types.
• Static or temporal: a snapshot ignores changes over time. For time-dependent prediction, the split and graph must respect the prediction timestamp.
• One graph or many: classifying individual molecules, for example, usually means learning from a collection of separate graphs rather than labels on nodes in one giant graph.

Choose the prediction unit

These are different experimental setups. For example, link prediction needs a careful definition of held-out positive edges and negative examples; a node-classification mask is not a substitute.

Build and inspect a small graph with NetworkX

NetworkX is useful for constructing, inspecting, visualizing, and running classical algorithms on small graphs. The Analytics Vidhya tutorial demonstrates a social-network graph and basic operations such as node degree, connected components, and shortest paths. NetworkX is generally not the tool to use for training a neural model on a large production graph: it is CPU-oriented and can become memory-bound.

Rank #2

Sale

Machine Learning with PyTorch and Scikit-Learn: Develop machine learning and deep learning models with Python

$34.23

Buy on Amazon

import networkx as nx

G = nx.Graph()
G.add_nodes_from([
    (0, {"features": [1.0, 0.0], "label": 0}),
    (1, {"features": [0.0, 1.0], "label": 1}),
    (2, {"features": [1.0, 1.0], "label": 0}),
])
G.add_edges_from([(0, 1), (1, 2)])

print("nodes:", G.number_of_nodes())
print("edges:", G.number_of_edges())
print("degree of node 1:", G.degree[1])
print("connected components:", list(nx.connected_components(G)))

This example uses an undirected graph. Its edges mean that information may pass in either direction. In a real project, document the source, time window, and semantics of each relationship before training.

Convert graph data into a PyTorch Geometric object

PyTorch Geometric (PyG) provides graph data structures and neural-network layers for PyTorch. Its Data object documentation describes common fields such as node features x, connectivity edge_index, and labels y.

import torch
from torch_geometric.data import Data

x = torch.tensor([
    [1.0, 0.0],
    [0.0, 1.0],
    [1.0, 1.0],
], dtype=torch.float)

# Each column is one directed message route: source -> target.
# Both directions are included for each undirected relationship.
edge_index = torch.tensor([
    [0, 1, 1, 2],
    [1, 0, 2, 1],
], dtype=torch.long)

y = torch.tensor([0, 1, 0], dtype=torch.long)
data = Data(x=x, edge_index=edge_index, y=y)

assert data.edge_index.dtype == torch.long
assert data.edge_index.shape[0] == 2
assert data.x.size(0) == data.y.size(0)
assert int(data.edge_index.max()) < data.num_nodes

edge_index has shape [2, number_of_edges]. The first row gives source node indices and the second gives destination indices, so each column describes one route along which messages can flow. If an undirected edge is represented in only one direction, information will not necessarily flow both ways.

Other useful fields include edge_attr for edge features and boolean masks such as train_mask, val_mask, and test_mask for selecting nodes. Dataset-specific conventions matter; inspect the data object and the relevant PyG dataset documentation rather than assuming every dataset has the same fields or split.

Understand message passing before choosing a layer

At layer l, a node v receives an aggregate of representations from its neighbors, then updates its own representation:

Rank #3

Sale

Deep Learning with PyTorch, Second Edition: Training and applying deep learning and generative AI models

$51.68

Buy on Amazon

m_v^(l) = AGGREGATE({h_u^(l) : u in N(v)})
h_v^(l+1) = UPDATE(h_v^(l), m_v^(l))

The aggregation must not depend on an arbitrary ordering of neighbors. Common operations include a sum, mean, or normalized weighted sum. Many layers incorporate a node’s own features using self-loops or a separate residual connection. One message-passing layer typically brings in information from about one hop; stacking two layers can incorporate information from about two hops, subject to the architecture and graph.

More layers are not automatically better. Repeated aggregation can make node representations too similar, a problem called over-smoothing. Large neighborhoods also increase memory and computation, particularly for high-degree nodes.

GCN: normalized neighbor aggregation

A common graph convolutional network (GCN) layer uses normalized adjacency:

H^(l+1) = σ(D̂^(-1/2) Â D̂^(-1/2) H^(l) W^(l))

Here A is the adjacency matrix,  = A + I adds self-loops, D̂ is the degree matrix of Â, H contains node representations, W is learned, and σ is an activation. PyG’s GCNConv documentation describes its layer behavior and options; check whether self-loops and normalization are handled by the selected layer before adding them manually.

GAT: learned weighting of neighbors

A graph attention network (GAT) learns coefficients that weight neighbors differently:

Rank #4

Sale

Mastering PyTorch: Create and deploy deep learning models from CNNs to multimodal models, LLMs, and beyond

$34.58

Buy on Amazon

h_v' = σ(Σ[u in N(v)] α_vu W h_u)

Multi-head attention combines several such computations. GAT can be a useful comparison when neighbors should not contribute equally, but it can require more memory and computation, especially around high-degree nodes. Its attention coefficients are model internals that can be inspected; they are not, by themselves, guaranteed faithful explanations of a prediction. See PyG’s GATConv documentation for layer parameters.

Train a small GCN for node classification

The Analytics Vidhya tutorial uses Cora, a small citation-network dataset commonly used to demonstrate transductive node classification. It is a convenient learning example with node features, labels, and citation edges, not a proxy for every real-world graph. Its split and benchmark assumptions may differ from a temporal or recommendation task.

For a Cora-style dataset whose object includes the three masks, this two-layer model follows the standard PyG pattern. Start by checking the current PyG installation guidance for a compatible PyTorch and accelerator setup rather than copying the tutorial’s older torch-1.9.0+cu111 command.

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

class GCN(torch.nn.Module):
    def __init__(self, in_channels, hidden_channels, out_channels):
        super().__init__()
        self.conv1 = GCNConv(in_channels, hidden_channels)
        self.conv2 = GCNConv(hidden_channels, out_channels)

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

# data is a PyG dataset graph with x, edge_index, y,
# train_mask, val_mask, and test_mask.
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
data = data.to(device)

model = GCN(
    in_channels=data.num_features,
    hidden_channels=64,
    out_channels=int(data.y.max()) + 1,
).to(device)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01, weight_decay=5e-4)

best_val_acc = -1.0
best_state = None
for epoch in range(1, 201):
    model.train()
    optimizer.zero_grad()
    logits = model(data.x, data.edge_index)
    loss = F.cross_entropy(logits[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()

    model.eval()
    with torch.no_grad():
        val_logits = model(data.x, data.edge_index)
        val_pred = val_logits.argmax(dim=-1)
        val_acc = (val_pred[data.val_mask] == data.y[data.val_mask]).float().mean().item()
        if val_acc > best_val_acc:
            best_val_acc = val_acc
            best_state = {k: v.detach().clone() for k, v in model.state_dict().items()}

model.load_state_dict(best_state)
model.eval()
with torch.no_grad():
    test_logits = model(data.x, data.edge_index)
    test_pred = test_logits.argmax(dim=-1)
    test_acc = (test_pred[data.test_mask] == data.y[data.test_mask]).float().mean().item()
print(f"best validation accuracy: {best_val_acc:.3f}")
print(f"test accuracy: {test_acc:.3f}")

This full-batch example computes logits for all nodes but calculates the loss only on training-mask nodes. Validation data guides checkpoint selection; the test mask is evaluated once after that selection. In a transductive setup, the graph structure and features may include validation and test nodes during message passing while their labels are withheld from the loss. That is a specific evaluation setting, not a universal rule. If deployment predicts into a future period or on a graph that does not yet exist, construct splits and edges to reproduce that information boundary.

The code illustrates a training pattern, not a guaranteed accuracy result. Scores depend on the dataset version, masks, seed, software, model settings, and hardware. For imbalanced labels, supplement accuracy with macro-F1, per-class recall, or a metric matched to the cost of errors. Keep a feature-only baseline under the same split to establish whether graph information actually helps.

Best Value

The Hundred-Page Language Models Book: hands-on with PyTorch (The Hundred-Page Books)

$46.95

Buy on Amazon

Move from node predictions to graph predictions

For graph classification, a model typically first computes node embeddings and then pools them into one graph-level vector before applying a classifier or regressor:

node features → GNN layers → global pooling → prediction head

Global mean, sum, or max pooling combines node representations within each graph. Hierarchical pooling instead coarsens or reduces a graph during the network. Neither should be confused with neighborhood aggregation: message passing updates node representations, while pooling creates a representation at a larger unit or reduces graph resolution.

Common failure modes and how to check them

• Malformed connectivity: verify that edge_index is a two-row integer tensor and node indices are in range. A transposed or incorrectly indexed tensor can make the model train on the wrong structure.
• One-way edges in an undirected task: store both message directions when the relationship is intended to be undirected.
• Missing self-information: confirm whether the chosen layer adds self-loops or uses a residual path; otherwise aggregation may not preserve a node’s own signal as intended.
• Label or time leakage: exclude post-outcome attributes and future edges; fit preprocessing on training data when the evaluation design requires it. For link prediction, hold out target edges correctly and define negatives carefully.
• Unrepresentative splits: random node masks are not automatically suitable for temporal prediction, recommendation, or deployment to new nodes.
• Class imbalance: accuracy can hide failures on rare classes. Inspect class counts and per-class metrics.
• Isolated or high-degree nodes: isolated nodes rely primarily on their own features and layer behavior; high-degree nodes can dominate compute and neighborhood sampling.
• Weak homophily: connected nodes do not always share labels. A GCN that works on a citation benchmark may underperform when neighboring nodes have different labels.
• Over-smoothing: if deeper models lose performance or embeddings become too similar, test fewer layers or architectures with residual, normalization, or jumping-knowledge connections.
• Outdated installation instructions: the tutorial’s PyTorch 1.9.0/CUDA 11.1 wheel is historically specific. It may be unsuitable for current Python, PyTorch, CUDA, or operating-system combinations; use the current compatibility instructions.

When the example must scale

The full-batch approach is convenient for small benchmark graphs because the whole graph is available for each update. For larger graphs, loading all features and connectivity at once may exceed memory or make training too slow. Neighbor sampling and mini-batch loaders limit the portion of the graph used in an update, at the cost of extra configuration and a sampling process that affects the training distribution.

Scaling decisions may also involve sparse storage, GPU memory, graph and feature updates, batch inference, cold-start nodes, temporal drift, and privacy constraints. A production system needs an explicit plan for keeping edges and features current and for monitoring whether the graph still reflects the prediction setting. A small Cora run alone does not establish that a model or pipeline is production-ready.

Choose the right tool for each part

For a first implementation, PyG is a natural fit for the tutorial’s code path, while NetworkX can help inspect a toy graph. A graph database or paid cloud GPU is optional; neither is necessary to run a small introductory example.

What the Analytics Vidhya tutorial is best for

The March 31, 2024 Analytics Vidhya article is most useful as a survey of graph vocabulary and introductory GNN patterns. It introduces NetworkX, PyG’s Data representation, message passing, GCN and GAT examples on Cora, pooling, applications, and challenges. Its installation command reflects an older PyTorch/CUDA combination, and its examples do not amount to a fully specified modern environment or a production data pipeline.

Use it to orient yourself, then make the task, graph semantics, split, baseline, and environment explicit in your own project. Treat benchmark scores as results for their exact setup, not as a promise about a different graph.

Quick Recap

SaleBestseller No. 1

Hands-On Machine Learning with Scikit-Learn and PyTorch: Concepts, Tools, and Techniques to Build Intelligent Systems

$77.72

SaleBestseller No. 2

Machine Learning with PyTorch and Scikit-Learn: Develop machine learning and deep learning models with Python

$34.23

SaleBestseller No. 3

Deep Learning with PyTorch, Second Edition: Training and applying deep learning and generative AI models

$51.68

SaleBestseller No. 4

Mastering PyTorch: Create and deploy deep learning models from CNNs to multimodal models, LLMs, and beyond

$34.58

Bestseller No. 5

The Hundred-Page Language Models Book: hands-on with PyTorch (The Hundred-Page Books)

$46.95

Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.