Going with the Flow: Approximating Banzhaf Values via Graph Neural Networks

TL;DR

This work tackles the intractability of computing the Banzhaf value in network flow games by proposing a Graph Neural Network (GNN) surrogate that predicts per-agent Banzhaf values from graph topology and edge ownership. Framing the task as a graph-level regression, the authors compare three GNN architectures (GAT, GINE, EdgeConv) on a large synthetic dataset, showing order-of-magnitude speedups over exact and Monte Carlo methods while achieving high fidelity predictions. A key finding is strong zero-shot generalisation: models trained on one graph size and topology accurately predict on unseen topologies without retraining, particularly with the GINE architecture. The results demonstrate that GNN-based approximations are a practical, scalable tool for cooperative game-theoretic analysis in complex networks, enabling rapid evaluation across dynamic or large-scale systems.

Abstract

Computing the Banzhaf value in network flow games is fundamental for quantifying agent influence in multi-agent systems, with applications ranging from cybersecurity to infrastructure planning. However, exact computation is intractable for systems with more than $\sim20$ agents due to exponential complexity $\mathcal{O}(2^m)$. While Monte Carlo sampling methods provide statistical estimates, they suffer from high sample complexity and cannot transfer knowledge across different network configurations, making them impractical for large-scale or dynamic systems. We present a novel learning-based approach using Graph Neural Networks (GNNs) to approximate Banzhaf values in cardinal network flow games. By framing the problem as a graph-level prediction task, our method learns generalisable patterns of agent influence directly from network topology and control structure. We conduct a comprehensive empirical study comparing three state-of-the-art GNN architectures-Graph Attention Networks (GAT), Graph Isomorphism Networks with Edge features (GINE), and EdgeConv-on a large-scale synthetic dataset of 200,000 graphs per configuration, varying in size (20-100 nodes), agent count (5-20), and edge probability (0.5-1.0). Our results demonstrate that trained GNN models achieve high-fidelity Banzhaf value approximation with order-of-magnitude speedups compared to exact and sampling-based methods. Most significantly, we show strong zero-shot generalisation: models trained on graphs of a specific size and topology accurately predict Banzhaf values for entirely new networks with different structural properties, without requiring retraining. This work establishes GNNs as a practical tool for scalable cooperative game-theoretic analysis of complex networked systems.

Figures (12)

• Figure 1: Overview of our GNN-based approach for Banzhaf value prediction. Left (Training phase): A network flow graph with edges controlled by three agents (colour-coded). Node features(type indices), edge features(normalised capacity and agent control) and degree features(in/out degree) are extracted and processed by three GNN architectures (GAT, GINE, EdgeConv) to predict the Banzhaf value vector. Right (Evaluation phase): The same trained models are applied to entirely different graph structures with more nodes and agents, demonstrating zero-shot generalisation across network topologies without additional training.
• Figure 2: Hexplot comparison of three model architectures on 5 agents on different-shaped graphs. Figures show graphs of sizes n=20, n=50 and n=100 for rows a,b and c, respectively. All of the edge probabilities are equal to p=0.5, with the horizontal axis representing the ground truth Banzhaf values, and the vertical axis the model's prediction. The colour indicates the point density (from low density(purple) to high density (yellow). The red dashed line indicates a perfect prediction.
• Figure 3: Cross-architecture edge-probability generalisation performance at $n=50$. Heatmaps show Huber loss for models trained and evaluated at different edge probabilities (p). Columns represent different agent counts ($m=5, 10, 20$). Each cell displays performance when a model trained at a given p-value (y-axis) is evaluated at another p-value (x-axis). Models trained at p=1.0 exhibit poor generalisation across all architectures, while optimal training regimes differ by architecture: $p=0.5$ for GINE, $p=0.8$ for GAT, and $p=0.6$ for EdgeConv.
• Figure 4: Detailed edge-probability generalisation analysis for GINE across all training configurations. Heatmaps show Huber loss (log scale) as a function of training edge probability (train_p, y-axis) and evaluation edge probability (eval_p, x-axis) for different graph sizes ($n=20, 50, 100$; rows) and agent counts ($m=5, 10, 20$; columns). Diagonal elements consistently achieve the lowest error (in-distribution), while off-diagonal performance degrades more severely for larger n values, indicating reduced generalisation capacity in larger graphs.
• Figure 5: Cross-architecture graph size generalisation performance at $m=10$. Heatmaps show Huber loss for models trained and evaluated at different numbers of nodes (n). Columns represent different edge probabilities ($p=0.5, 0.7, 1.0$). Each cell displays performance when a model trained at a given n-value (y-axis) is evaluated at another n-value (x-axis). Models trained at n=100 exhibit poor generalisation across all architectures, while optimal training regimes differ by architecture: $n=20$ for GINE and EdgeConv, $n=50$ for GAT.

Theorems & Definitions (4)

• Definition 1: TU-game
• Definition 2: Banzhaf Value
• Definition 3: Network Flow Game Setup
• Definition 4: Cardinal Network Flow Game