Graph neural networks (GNNs) process relational data. The core idea is not merely reshaping tabular data—but enabling nodes to exchange information across edges. This article focuses on performance evaluation. Speed, accuracy, GPU memory usage, and reproducible experimental settings must all be recorded together; no single metric tells the full story.

I begin by visualizing nodes, edges, and target labels—then decide whether the task is node classification, link prediction, or graph-level classification. Different tasks demand different evaluation strategies.

In the previous article, we explored the model architecture of graph neural networks (GNNs), covering their fundamental building blocks and functionalities. Next, we delve into performance evaluation methods for GNNs—ensuring we can rigorously assess the validity and accuracy of the models we build.

Why Performance Evaluation Matters

In machine learning and deep learning, performance evaluation is a critical step. Especially when handling complex data structures like graphs, evaluating model performance helps us understand both its potential and its limitations. Performance evaluation typically encompasses the following aspects:

While reading this article, treat the sequence “Importance of Performance Evaluation → Key Metrics → Accuracy → Precision & Recall” as a verification checklist: first grasp the materials, actions, and outcomes; then revisit concrete examples, code snippets, or metrics to cross-check.

1. Accuracy: Measures the proportion of correct predictions.
2. Precision: Measures the fraction of true positives among all instances predicted as positive.
3. Recall: Measures the fraction of true positives among all actual positive instances.
4. F1 Score: The harmonic mean of precision and recall—balancing false positives and false negatives.
5. AUC-ROC Curve: A metric for evaluating binary classifiers, indicating how well the model separates positive and negative classes.

Key Performance Metrics

1. Accuracy

For a classification task, accuracy is computed as follows:

$$\text{Accuracy} = \frac{TP + TN}{TP + TN + FP + FN}$$

where $TP$ = true positives, $TN$ = true negatives, $FP$ = false positives, and $FN$ = false negatives.

2. Precision and Recall

The formulas for precision and recall are:

$$\text{Precision} = \frac{TP}{TP + FP}$$ $$\text{Recall} = \frac{TP}{TP + FN}$$

These two metrics are especially valuable in imbalanced-class scenarios.

3. F1 Score

To jointly account for precision and recall, we compute the F1 score:

$$F1 = 2 \times \frac{\text{Precision} \times \text{Recall}}{\text{Precision} + \text{Recall}}$$

Case Study in Performance Evaluation

Let’s deepen our understanding through a practical example. Suppose we have a GNN model for node classification—e.g., classifying user attributes in a social network. Here’s how we perform performance evaluation:

Dataset

We use the Cora dataset—a standard benchmark in graph learning—comprising scientific papers and citation relationships among them.

Model Training

We construct a simple Graph Convolutional Network (GCN) as our GNN model and train it on the Cora dataset. Below is a PyTorch-based implementation example:

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

# Load the Cora dataset
dataset = Planetoid(root='/tmp/Cora', name='Cora')
data = dataset[0]

# Define the GCN model
class GCN(torch.nn.Module):
    def __init__(self, num_features, num_classes):
        super(GCN, self).__init__()
        self.conv1 = GCNConv(num_features, 16)
        self.conv2 = GCNConv(16, num_classes)

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

model = GCN(num_features=dataset.num_features, num_classes=dataset.num_classes)
optimizer = torch.optim.Adam(model.parameters(), lr=0.01)

# Train the model
def train():
    model.train()
    optimizer.zero_grad()
    out = model(data)
    loss = F.nll_loss(out[data.train_mask], data.y[data.train_mask])
    loss.backward()
    optimizer.step()

for epoch in range(200):
    train()

# Evaluate model performance
def test():
    model.eval()
    out = model(data)
    pred = out.argmax(dim=1)
    test_correct = pred[data.test_mask] == data.y[data.test_mask]
    accuracy = int(test_correct.sum()) / data.test_mask.sum().item()
    return accuracy

accuracy = test()
print(f'Test Accuracy: {accuracy:.4f}')

Performance Evaluation and Analysis

After training and testing, we comprehensively analyze model performance using the metrics introduced above:

• Compute accuracy, precision, recall, and F1 score on the test set;
• Visualize per-class prediction performance via a confusion matrix.

At this point, you can organize “Performance Evaluation of Graph Neural Networks” into a retrospective table: first clarify the main thread, then verify results using a small-scale task.

After finishing “Performance Evaluation of Graph Neural Networks”, try walking through a small example end-to-end first—then identify which steps you can already execute independently.

Summary

In this article, we thoroughly examined performance evaluation methods for graph neural networks—including definitions and calculations of key metrics. Through a concrete case study, we demonstrated how to build a GNN model with PyTorch and conduct rigorous evaluation. These methods provide essential guidance for subsequent model refinement and optimization.

In the next article, we will explore the core techniques of capsule networks—delving deeper into the characteristics and applications of this emerging neural architecture.

When studying “Performance Evaluation of Graph Neural Networks”, start with a small scenario you can reproduce yourself; then examine related concepts and practice each step. After reading, retell the entire process using your own example.