arXiv:2609.08970v1 [cs.LG] 8 Sep 2026
GraphFAS: A Distributed System for Automated Graph Feature Generation and Selection in Industrial Transaction Networks Yice Luo
Yun Zhu
Xi Chen
Ant Group Hangzhou, China
Ant Group Hangzhou, China
Ant Group Hangzhou, China
Yongchao Liu∗
Xintan Zeng
Chengying Huan
Ant Group Hangzhou, China [email protected]
Ant Group Hangzhou, China
Nanjing University Nanjing, China
Kai Zhang
Jinrui Zhang
Juelu Zhang
Ant Group Hangzhou, China
Ant Group Hangzhou, China
Ant Group Hangzhou, China
Jiajun Zheng Ant Group Hangzhou, China
Abstract
Keywords
Industrial fraud detection often relies on costly expert-crafted features that overlook graph-structured relational signals, while GNNs often do not meet the interpretability and deployment requirements of financial risk control. We propose GraphFAS (Graph Feature Automated Selection), a distributed feature selection procedure based on Boruta that bridges this gap through: (1) a non-parametric graph feature generation module that constructs explicit, interpretable structural features via multi-hop subgraph extraction and multi-scale aggregation without learned parameters; and (2) an automated distributed feature selection algorithm extending Boruta with median-based aggregation across partitions to robustly identify informative features at scale with minimal domain expertise. Compared with end-to-end GNN pipelines, GraphFAS decouples feature aggregation from model training, enabling direct integration with tabular models and direct compatibility with TreeSHAPbased explanations. Deployed in Alipay, GraphFAS delivers orderof-magnitude improvements in engineering efficiency while showing strong performance against expert-driven and graph-learning baselines on large-scale graphs.
Feature Selection, Graph Feature Generation, Interpretability, Distributed Graph Mining, Fraud Detection
CCS Concepts • Information systems → Data mining. ∗ Corresponding author.
† Corresponding authors; We thank Mingyao Li, Yuhang Chen, Yue Jin and Chuntao
Hong for their help and contributions.
This work is licensed under a Creative Commons Attribution 4.0 International License. CIKM ’26, Rome, Italy © 2026 Copyright held by the owner/author(s). ACM ISBN 979-8-4007-2539-5/2026/11 https://doi.org/10.1145/3799682.3840143
ACM Reference Format: Yice Luo, Yun Zhu, Xi Chen, Yongchao Liu, Xintan Zeng, Chengying Huan, Kai Zhang, Jinrui Zhang, Juelu Zhang, and Jiajun Zheng. 2026. GraphFAS: A Distributed System for Automated Graph Feature Generation and Selection in Industrial Transaction Networks. In Proceedings of the 35th ACM International Conference on Information and Knowledge Management (CIKM ’26), November 07–11, 2026, Rome, Italy. ACM, New York, NY, USA, 8 pages. https://doi.org/10.1145/3799682.3840143
1
Introduction
Fraud detection [1, 2] in large-scale transaction networks is a critical task for financial platforms. On systems such as Alipay, effective detection mechanisms prevent financial losses amounting to millions of CNY daily. These transaction networks comprise hundreds of millions of users and massive edge volumes, where fraudulent activities exhibit organized collusion and complex interaction patterns inherently suited for graph-based analysis. Existing industrial solutions predominantly rely on expert-crafted features developed through labor-intensive manual processes. As illustrated in Figure 1, graph feature engineering entails three stages: (1) expert-driven pattern analysis requiring specialized domain knowledge, (2) large-scale simulations over massive credit networks, and (3) iterative multi-dimensional evaluations for stability validation. This manual cycle often spans over a month with no guarantee of optimal outcomes. Moreover, conventional attribute-centric approaches may under-utilize the rich relational signals embedded in graph structures, leaving critical topological patterns undetected. Graph neural networks (GNNs) capture structural dependencies through iterative message passing, achieving strong performance on various graph learning tasks. However, GNNs face fundamental limitations in financial risk control scenarios. First, their multi-layer transformations can make decision processes harder to interpret
CIKM ’26, November 07–11, 2026, Rome, Italy Experts Proposing Features
Feature Simulation
Evaluation and Report
²
Û
Experts’ Brainstorm
Analysis
Conclusion
Yice Luo et al. - High Cost Specialized & Time-consuming
¨
e
Æ
O
Graph Cons.
Data Exp.
Simulation
Feat. Gen.
¡
@
Evaluation
Report
- High Latency Expensive & Slow
- Inefficient
Labor-intensive & Low success
Figure 1: Traditional feature engineering workflows. The manual process is high-cost, while simulation is computationally expensive. that conflict with regulatory requirements for model transparency. Second, the computational overhead of end-to-end training introduces significant latency that conflicts with low-latency feature production requirements on large-scale industrial networks. Third, GNN embeddings often lack explicit semantics that are easy to validate in risk analysis workflows, making them difficult to validate and deploy in production environments. To overcome the limitations of both manual feature engineering and opaque GNN embeddings, recent research has explored automated graph feature construction. Frameworks such as TAG [10], G2T-FM [5], and TabPFN-GN [4] construct node representations from topology using predefined structural encoders. While these approaches reduce manual intervention, they introduce new challenges that motivate our work: • Challenge 1: Lack of interpretability in graph learning models. GNNs generate latent embeddings that are opaque to domain experts and regulators. Financial risk control requires explicit, human-interpretable features that can be directly validated and audited. The first challenge is to design a feature generation mechanism that captures multi-hop relational dependencies while producing semantically meaningful, tabular-compatible features with native TreeSHAP explainability (Section 3.1). • Challenge 2: Scalability limitations of existing feature selection methods. Traditional feature selection algorithms such as Boruta [16] operate on standalone environments and lack distributed computation support. Industrial graphs with massive edge volumes require partition-based processing, but aggregating importance scores across partitions introduces instability under skewed class distributions. The second challenge is to design a distributed adaptation with robust aggregation mechanisms for efficient high-dimensional feature screening across partitioned datasets (Section 3.2). • Challenge 3: Inflexibility of automated graph feature pipelines. Existing automated methods rely on static, predefined encoders or require complex, non-scalable training procedures. Foundation model-based approaches struggle to generalize across diverse, multi-type graph structures typical of heterogeneous financial networks. The third challenge is to decouple feature generation from model training to enable feature selection without end-to-end retraining or reliance on fixed encoder sets (Section 3).
To address these challenges, we present GraphFAS (Graph Feature Automated Selection), a distributed graph feature selection system deployed in Alipay. Our design is based on the observation that decoupling non-parametric graph feature aggregation from downstream model training enables both scalability and interpretability. By generating explicit structural statistics rather than learned embeddings, GraphFAS achieves seamless integration with tabular learning models while maintaining native explainability. In GraphFAS, graph features are constructed through multi-hop subgraph extraction and multi-scale aggregation without learned parameters, enabling CPU-based execution and good distributed scalability. The distributed feature selection module extends the Boruta algorithm with median-based aggregation across partitions, making the procedure less sensitive to outlier partitions arising from skewed class distributions. This design enables automated feature selection at scale while reducing the need for manual expert intervention. We evaluate GraphFAS on eight public benchmarks and three industrial datasets 1 . GraphFAS performs competitively on public benchmarks and shows strong results on industrial datasets. Deployed on large-scale transaction networks, GraphFAS processes millions of seed nodes daily across multiple risk control scenarios. The technical contributions are summarized as follows: • A scalable graph feature generation module. We propose a scalable feature generation module that constructs explicit, interpretable structural features via multi-hop subgraph extraction and multi-scale aggregation without learned parameters. This enables efficient processing of large-scale industrial graphs while producing TreeSHAP-compatible tabular features (Section 3.1). • A distributed Boruta-based feature selection module. We extend the Boruta algorithm with median-based aggregation across partitions, enabling robust distributed feature selection for large-scale graph data. This approach provides resilience against outlier partitions while automatically identifying informative features without domain expertise (Section 3.2). • Industrial deployment and evaluation. We demonstrate the practical effectiveness of GraphFAS through deployment in Alipay. Our system achieves over 10× reduction in feature engineering cycle time while uncovering fraud patterns with substantially higher detection rates than expert-crafted baselines (Section 5).
2 Background and Related Work 2.1 Problem Formulation We reformulate graph representation learning by decoupling feature aggregation from end-to-end training. Formally, let 𝐺 = (𝑉 , 𝐸) denote a graph with node set 𝑉 and edge set 𝐸. Traditional GNNs update node representations through
1 The data used in this research does not involve any Personal Identifiable Informa-
tion(PII) and were all processed by data abstraction and data encryption, and the researchers were unable to restore the original data. Sufficient data protection was carried out during the process of experiments to prevent the data leakage and the data was destroyed after the experiments were finished. The data is only used for academic research and sampled from the original data, therefore it does not represent any real business situation in Ant Financial Services Group.
GraphFAS : A Distributed System for Automated Graph Feature Generation and Selection in Industrial Transaction Networks
CIKM ’26, November 07–11, 2026, Rome, Italy
Table 1: Summary of graph metrics by category. Category
Distance
Connection
Spectral
Metric
Hopcount Closeness Eccentricity Diameter
Degree Entropy Assortativity Coreness
Algebraic connectivity Spectral radius Spectral partitioning Principal eigenvector
GeaLearn Distributed System (Dataflow) Kubernetes Cluster Multicore CPU Nodes
(1)
where h𝑣(𝑙 ) denotes the embedding of node 𝑣 at layer 𝑙, e𝑢𝑣 denotes the edge from 𝑢 to 𝑣, N (𝑣) is its neighborhood, 𝜓 (𝑙 ) (·) is a parameÉ terized feature aggregation function, is a permutation-invariant aggregation operator, and 𝜙 (𝑙 ) (·) is an update function. Instead of learning parameterized aggregation functions, we perform non-parametric feature aggregation through algorithmic graph transformations: F = ANP (𝐺),
(2)
where ANP (·) denotes a parameter-free operator that computes graph-level and node-level statistics without gradient-based optimization. To enhance discriminative power and reduce redundancy, an automated feature selection operator S(·) is subsequently applied: F∗ = S(F; Φ), (3) where Φ denotes the distributed selection configuration, including partition-wise importance estimation, cross-partition aggregation, and final tentative-feature ranking. The selected features F∗ are then utilized by a lightweight predictive model: 𝑌ˆ = 𝑓𝜃 (F∗ ),
Graph Feature Generation
Distributed Programming Interface (API/SDK)
parameterized neighborhood aggregation: Ê ª © 𝜓 (𝑙 ) h𝑢(𝑙 ) , h𝑣(𝑙 ) , e𝑢𝑣 ® , h𝑣(𝑙+1) = 𝜙 (𝑙 ) h𝑣(𝑙 ) ; 𝑢 ∈ N (𝑣) ¬ «
Graph Feature Selection
GraphFAS
(4)
Figure 2: An example of graph-based features.
Figure 3: System architecture of GraphFAS.
attributes. GNNs (GCN [15], GAT [28]) achieve strong performance through message passing but suffer from three critical limitations in industrial settings: (1) opaque embeddings violate regulatory transparency requirements; (2) end-to-end training introduces significant latency that conflicts with low-latency feature production requirements on large-scale networks; (3) latent representations lack semantic meaning for actionable analysis. Post-hoc explainability methods (GNNExplainer [34], PGExplainer [21]) generate soft masks highlighting important subgraphs. However, soft masks require thresholding for practical use, while hard masks are more applicable in industrial settings [3]. These methods produce approximations rather than exact attributions and cannot directly output tabular features for downstream tasks [14]. In contrast, our approach generates inherently interpretable structural statistics compatible with native TreeSHAP explainability. Graph-to-Tabular Methods. Recent approaches (TAG [10], G2T-FM [5], TabPFN-GN [4], GraphPFN [6]) automate graph feature generation for tabular models. However, they rely on static predefined encoders or require complex training, limiting adaptability to diverse graph structures and scalability to industrial networks.
Finally, a task-specific loss function L (𝑌, 𝑌ˆ ) is applied to optimize the predictive model. This framework supports efficient processing of industrial-scale graphs while preserving feature interpretability.
2.2
Graph Feature Definition
Graph features capture structural characteristics through graph metrics and aggregation functions. Table 1 summarizes twelve metrics classified into three categories [11]: distance-based, connectionbased, and spectral. We combine these with non-parametric aggregators [30, 32] to integrate neighbor features while maintaining interpretability.
2.3
Related Work
Feature Selection Methods. Wrapper-based methods like Boruta [16] identify significant features by comparing them against randomly permuted shadow features. While effective [18, 22], existing implementations lack distributed support, hindering scalability for large-scale graph datasets. Filter methods (mutual information, statistical tests) are efficient but ignore feature interactions and structural dependencies. Graph Representation Learning. Random walk methods (DeepWalk [23], Node2Vec [8]) and spectral approaches produce node embeddings but lack interpretability and fail to incorporate node
2.4
Research Gap and Motivation
Existing approaches exhibit three technical limitations that motivate our work. First, wrapper-based feature selection methods lack distributed adaptations—Boruta operates on standalone environments without partition-aware aggregation mechanisms, making it intractable for large-scale datasets. Second, current graph learning methods force a trade-off between performance and interpretability: GNNs produce opaque embeddings unsuitable for regulatory audit, while post-hoc explainers provide approximations rather than exact attributions. Third, automated graph-to-tabular pipelines rely on static pre-defined encoders that cannot adapt to diverse heterogeneous graph structures without complex retraining. We leave such benchmarking to future work. GraphFAS addresses these gaps through: (1) a distributed Boruta adaptation with median-based aggregation for robust feature selection at scale; (2) non-parametric graph feature generation producing inherently interpretable structural statistics compatible with native TreeSHAP explainability; (3) decoupled feature generation and automated selection enabling scalable deployment without end-to-end retraining.
CIKM ’26, November 07–11, 2026, Rome, Italy
Yice Luo et al.
Algorithm 1: Feature Selection of GraphFAS
Confirmed?
Sampler
Parameter-free operator
Input: Dataset 𝐷 , partitions 𝑤 , max iterations 𝑇 Output: Confirmed features 𝐹 final 1 {𝐷𝑖 } 𝑤 ← Partition (𝐷, 𝑤 ) ; 𝑖=1 2 ∀𝑓 𝑗 ∈ 𝐹, state 𝑗 ← Tentative;
No
3
Generate shadow features 𝐹e𝑖 on each worker 𝑃𝑖 ; for 𝑡 = 1 to 𝑇 do // Local importance computation 5 for each partition 𝐷𝑖 do
4
Industrial-scale graph
K-hop subgraphs
Graph features Concat. Shadow features
Hit features
Figure 4: GraphFAS procedure overview.
3
The GraphFAS Framework
The calculation procedure for GraphFAS (Figure 4) comprises two key design elements: (1) graph feature generation, which extracts 𝑘-hop subgraphs from seed nodes, computes graph metrics, and aggregates them to create candidate features; and (2) distributed feature selection, which employs a Boruta-based algorithm to filter out low-importance features.
3.1
Graph Feature Generation
The feature generation process involves three stages: K-hop Subgraph Extraction. For each node, ego-subgraphs are generated at different hop levels (1-hop, 2-hop, 3-hop) using neighborhood sampling, capturing localized structural patterns at varying depths. Feature Generation from Graph Metrics. Given a subgraph centered at target node 𝑣, we compute graph metric functions to extract feature values characterizing local structural properties (connectivity patterns, centrality, neighborhood composition). These metric-based features are concatenated with the aggregated graph feature vector, yielding an enhanced representation encoding both intrinsic attributes and structural context. All generated features are inherently interpretable—e.g., average transaction frequency among 2-hop risky neighbors or fraud concentration ratio within immediate neighborhood (Figure 2 illustrating an example of graph-based features highlighting suspect connectivity to known debtors. A node with 0.2 debtor ratio in 1-hop and 1.0 in 2-hop neighborhood suggests elevated risk even when the individual is not a debtor, demonstrating the capacity to identify latent risks through local topology)—enabling direct validation by domain experts. Unlike conventional pipelines requiring manual metric selection, GraphFAS automatically evaluates and ranks features from a large candidate pool, ensuring both predictive performance and scalability. Feature Aggregation. Multi-scale features are aggregated hierarchically: 1-hop aggregation (Mean/Max pooling of immediate neighbors), 2-hop aggregation (variance/skewness of secondary neighbors), and combined features (concatenation of raw features with aggregated features). We employ six complementary aggregation functions: Max/Min (extreme behaviors), Mean/Std (distributional properties), Sum (cumulative effects), and Count (structural density). Implementation hyperparameters are detailed in Table 3.
3.2
Distributed Feature Selection
GraphFAS employs a wrapper-style feature selection stage that iteratively evaluates feature importance against shuffled shadow
7
(𝑡,𝑖 ) e(𝑡,𝑖 ) for 𝑓e𝑘 ∈ 𝐹e𝑖 ; Compute 𝑍 𝑗 for 𝑓 𝑗 ∈ 𝐹 , 𝑍 𝑘 (𝑡 ) (𝑡 ) (𝑡,𝑖 ) e e(𝑡,𝑖 ) ; 𝑍emax ← max𝑖 𝑍e ;𝑍 ← min 𝑖𝑍 min
8
// Median aggregation across partitions for each feature 𝑓 𝑗 ∈ 𝐹 with state 𝑗 = Tentative do
6
9 10 11 12 13 14
(𝑡 )
(𝑡,𝑖 ) 𝑤 ← Median ( {𝑍 𝑗 }𝑖=1 ) ; (𝑡 ) (𝑡 ) e if 𝑍 𝑗 > 𝑍 max then state 𝑗 ← Confirmed; (𝑡 ) e(𝑡 ) then else if 𝑍 𝑗 < 𝑍 min state 𝑗 ← Rejected;
𝑍𝑗
if no Tentative features remain then break; // Rank-based retention of tentative features
15
𝑡
16
(𝑡 ) e(𝑡 ) /𝑍 max for all 𝑓 𝑗 ;
Rank (𝑓 𝑗 ) ← median 𝑍 𝑗
𝐹 final ← { 𝑓 𝑗 | state 𝑗 = Confirmed } ∪ Top-K ( Rank ) ; Output: 𝐹 final
features. For industrial-scale graphs, GraphFAS employs partitionbased selection: the graph is divided into 𝑤 parts, each generating hybrid shadow features via random permutation (Algorithm 1). In each iteration, each partition calculates importance for candidate and shadow features (Line 6). The median importance across partitions determines feature status: confirmed if exceeding all shadows, rejected if below all. After iterations, confirmed features plus top-𝑘 ranked tentative features are selected (Line 16). Hyperparameter Settings. Key hyperparameters are summarized in Table 3: max iterations 𝑇 = 100, median aggregation, and top𝑘 = 500 fallback for tentative features. Connection to Explainability. The feature selection process naturally supports post-hoc explainability. Since selected features are explicit structural statistics (e.g., "2-hop fraud neighbor ratio"), TreeSHAP can directly attribute predictions to human-interpretable graph patterns without additional approximation techniques required by GNN embeddings. This straightforward integration facilitates model interpretation in compliance-oriented settings. Importance Score Computation. The importance score of features can be computed through impurity-based metrics (e.g., Gini coefficient) or Shapley value-based explanations [29]. LightGBM natively supports both approaches, with distinct computational characteristics for each. Shapley values [25] quantify the marginal contribution of each feature across all possible feature subsets. Exact computation is NP-hard with exponential complexity 𝑂 (2 |𝐹 | ), where 𝐹 denotes the set of all input features. TreeSHAP [20] leverages the internal structure of tree-based models to reduce complexity to polynomial time 𝑂 (𝑇 · 𝐿 · |𝐹 | 2 ), where 𝑇 is the number of trees and 𝐿 is the maximum tree depth. By recursively traversing decision tree paths rather than enumerating all permutations, TreeSHAP enables practical application in domains requiring both transparency and computational efficiency. In GraphFAS, we employ TreeSHAP for feature importance computation due to its scalability on industrial-scale graphs.
GraphFAS : A Distributed System for Automated Graph Feature Generation and Selection in Industrial Transaction Networks
Final Ranking. Features are ranked by stability score: median normalized importance relative to maximum shadow value. Let 𝑍 𝑗(𝑡 ) denote the median importance score of feature 𝑓 𝑗 at iteration 𝑡 ag(𝑡 )
gregated across all partitions (i.e., 𝑍 𝑗(𝑡 ) = 𝑍 𝑗 in Algorithm 1), and 𝑍e(𝑡 ) denote the importance scores of shadow features at iteration 𝑡. The final rank is computed as: (𝑡 ) © 𝑍𝑗 ª Rank(𝑓 𝑗 ) = median ® 𝑡 =1...𝑇 max(𝑍e(𝑡 ) ) « ¬
(5)
Top-𝑘 features are selected from tentative features by this rank.
4
Distributed Implementation
GraphFAS is implemented on GeaLearning [13, 19, 27, 31], a distributed graph computing system employing a Manager-Worker architecture. The Manager initializes the cluster topology, coordinates distributed execution, and aggregates feature importance scores across workers. It instantiates a Driver module that encapsulates the algorithmic logic. Workers execute parallel graph operations with dynamic workload monitoring. This architecture decouples control from computation, enabling GraphFAS to process massive graph datasets with optimal resource utilization. Figure 3 depicts the layered system architecture of GraphFAS. The top layer comprises the core GraphFAS components: feature generation and feature selection modules. These interface with the underlying distributed computing infrastructure through the GeaLearn distributed programming interface, which manages dataflow across a Kubernetes cluster deployed on multicore CPU nodes.
4.1 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23
Distributed GraphFAS
class GraphFAS : public gealearn :: Driver { void run ( gealearn :: DriverContext & context ) { // Load graph context . runProcedure ( " GraphFASGraphImport " ) ; // Feature generation context . runProcedure ( " GraphFASFeatureGeneration " ) ; features . initialize ( " tentative " ) ; // Feature selection for ( int iter = 0; iter < max_iteration && features . exist ( " tentative " ) ; iter ++) { context . runProcedure ( " calculateImportance " ) ; context . allReduce ( features ) ; for ( auto feature : features ) { if ( feature . median > features . shadow . max ) feature . set ( " confirmed " ) ; if ( feature . median < features . shadow . min ) feature . set ( " rejected " ) ; } } // Rank features context . runProcedure ( " GraphFASFeatureRanking " ) ; } };
Listing 1: Implementation of GraphFAS Our distributed implementation of GraphFAS adheres to the Manager-Worker paradigm of GeaLearning. In this setup, the manager node is responsible for loading the graph and synchronizing the importance scores of features across all worker nodes.
CIKM ’26, November 07–11, 2026, Rome, Italy
In alignment with the description provided in Algorithm 1, GraphFAS utilizes the median value of a feature to update its state. To facilitate synchronization in a distributed environment, an additional allReduce function has been incorporated. This function ensures that the importance scores are consistently aggregated and updated across all nodes.We show in detail how each stage of GraphFAS is implemented in the distributed environment: Graph Loading. Given the raw dataset 𝐷 ∈ R𝑛×𝑚 with 𝑛 samples and 𝑚 features, we employ 1D Distributed Sample Transposition (1D-DST) to efficiently distribute the data across multiple worker processes. The dataset 𝐷 is partitioned into 𝑤 shards, denoted as 𝑤 , where each shard 𝐷 is assigned to a worker process P . {𝐷𝑖 }𝑖=1 𝑖 𝑖 Each worker maintains a submatrix 𝐷𝑖 ∈ R𝑛𝑖 ×𝑚 with 𝑛𝑖 ≈ 𝑤𝑛 , ensuring that the computational load is balanced across the clusters through dynamic workload monitoring. Feature Generation in Distributed Environment. To incorporate subgraph features as candidate features, GraphFAS employs a distributed sampling strategy for efficient extraction and processing. The process starts with generating 𝑘-hop subgraphs for seed nodes, performed in parallel across multiple worker nodes. Each worker collects edges associated with its assigned seed nodes; if an edge 𝐸 = (𝑣 1, 𝑣 2 ) ∈ 𝐸 belongs to multiple seed nodes, it is replicated across workers to maintain subgraph completeness. After extraction, workers independently calculate subgraph features, such as averaging node features within each subgraph, ensuring efficient and consistent feature generation. Distributed Training and Feature Selection. Each worker in GraphFAS trains its own importance scoring model using its partitioned data, running in parallel to maximize computational efficiency. After training, the manager node synchronizes the importance scores from all workers. It then aggregates this information to select features with higher importance. Median aggregation provides resilience against outlier partitions arising from skewed class distributions, as the median is less sensitive to extreme values compared to the mean.
5 Experiments 5.1 Experimental Setup 5.1.1 Datasets. We evaluate GraphFAS on eight public benchmarks from PyTorch Geometric and SNAP, and three industrial datasets from Alipay. Table 2 provides statistics. Public datasets. Public datasets include eight citation, co-purchasing, and social networks from PyG and SNAP.Small-scale datasets use 60%/20%/20% train/validation/test splits; large-scale datasets (Flickr, Reddit) use standard predefined splits [35]. Industrial datasets. Dataset1-1M (2.8M edges), Dataset2-5M (10.9M edges), and Dataset3-97M (285.4M edges) are transaction networks with multi-relational edges (chatting, financial cooperation, payment, trade) and authentic fraud labels. Nodes have 87dimensional features. Due to severe class imbalance (<0.1% positive samples), we use AUC-ROC as the primary evaluation metric. 5.1.2 Implementation Settings. Public dataset experiments use a 64-core Intel Xeon E5-2682 v4 CPU with 256GB RAM. Industrial experiments use Kubernetes production clusters. Evaluation metrics:
CIKM ’26, November 07–11, 2026, Rome, Italy
Yice Luo et al.
Table 2: Statistics of public and industrial datasets Nodes
Edges
Features
Classes
Seeds
Cora [24] CiteSeer [7] PubMed [33] DBLP [24] Computers [26] Photo [26] Flickr [35] Reddit [35]
2,708 3,186 19,717 17,716 13,752 7,650 89,250 232,965
5,429 4,277 44,338 105,734 491,722 238,162 899,756 23,213,838
1,433 3,703 500 1,639 767 745 500 602
7 6 3 4 10 8 7 41
2,708 3,186 19,717 17,716 13,752 7,650 89,250 232,965
Dataset1-1M Dataset2-5M Dataset3-97M
1,463,690 5,629,431 97,262,426
2,828,041 10,919,773 285,366,878
87 87 87
2 2 2
25K 70K 3.5M
95 Accuracy (%)
Datasets
Parameter
Value / Setting
Subgraph Extraction
Max hop distance Sampling budget Neighborhood strategy
3 10,000 nodes per seed Random sampling
Feature Generation
Graph metrics Aggregation functions Candidate pool size
12 metrics (Table 1) mean, max, min, std, sum, count ∼500 features
Feature Selection
Max iterations (𝑇 ) Aggregation across partitions Shadow feature generation Final selection
100 Median Random permutation per partition Confirmed + top-500 tentative
Downstream Model
Model Learning rate Num leaves Feature fraction Early stopping
LightGBM 0.05 31 0.8 50 rounds patience
Accuracy (small public datasets), Micro-F1 (large public datasets), AUC-ROC (industrial datasets). Hyperparameters are summarized in Table 3.
5.2
Public Graph Benchmarks
5.2.1 Baselines and Setup. We compare GraphFAS with twelve baselines: (1) Traditional ML: LR [12], LightGBM [14] and MLP; (2) Deep graph learning: GCN [15], GraphSAGE [9], GAT [28], SGC [30], GIPA [17, 36]; (3) Feature selection: PCA, RFE, F-test and MI. All methods use grid search. 5.2.2 RQ1: Comparison with GNN Methods. Table 4 presents node classification results (mean±std over five runs). GNNs like GCN outperform traditional methods (LR, LGBM) by over 10% on Cora and 7% on DBLP, indicating that inherent structural information is highly effective. GraphFAS harnesses this information via its Graph Feature Generation Module while employing automated Feature Selection to identify the most informative features and mitigate overfitting. GraphFAS achieves competitive results with SOTA GNNs on smaller datasets and over 1% absolute improvement on larger datasets (DBLP, Flickr), demonstrating strong suitability for large-scale graphs. 5.2.3 RQ2: Comparison with Feature Selection Methods. Feature selection methods (MI, F-test) generally underperform compared to traditional ML due to information loss. For instance, RFE falls behind LGBM by approximately 2% and 1% on Cora and DBLP, indicating that aggressive feature pruning harms predictive accuracy. GraphFAS overcomes this by automatically generating and selecting informative graph features, achieving 10-20% absolute improvements over feature selection baselines.
85 80
DBLP Computers Photo
75
Table 3: Hyperparameter settings of GraphFAS. Component
90
10
100
300
500
Number of Features
700
Figure 5: Sensitivity analysis on the number of features
5.3
Industrial Case Studies
5.3.1 Baselines. We select GIPA [17] as a representative industrialstrength baseline, given its demonstrated superiority over standard GNNs on public benchmarks and its deployment in production environments. Standard GNNs (e.g., GCN, GraphSAGE) consistently underperform GIPA on industrial datasets [17] and are excluded to focus on competitive baselines. 5.3.2 RQ3: Effectiveness on Fraud Detection. Table 5 shows GraphFAS consistently outperforms GIPA on all three industrial datasets. The most substantial gain is on Dataset1 (2.82M edges): 6.14% absolute AUC improvement (86.26% vs. 80.12%). On Dataset3 (285.37M edges), GraphFAS achieves very strong discrimination (99.90% AUCROC) vs. GIPA’s 95.21%. Three key insights emerge: (1) GraphFAS effectively captures discriminative patterns from multi-relational graphs with four distinct edge types; (2) it maintains strong performance under severe class imbalance (<0.1% positive samples), demonstrating the automated Boruta-based mechanism’s effectiveness; (3) consistent improvements across two orders of magnitude in graph size (∼3M to ∼285M edges) suggest good distributed scalability (Section 5.4).
5.4
Efficiency Analysis and Ablation Study
5.4.1 RQ4: Scalability. We evaluate scalability on Dataset3-97M across 16, 32, and 64 containers (8 cores per container, five runs averaged). Execution times are 3866 seconds (16 nodes, 32GB per node, denoted 16N-32G), 2014 seconds (32N-16G), and 1075 seconds (64N-8G). Scaling from 16 to 32 containers reduces runtime by 47.9% (3866 seconds → 2014 seconds), yielding 1.92× speedup; scaling from 32 to 64 containers achieves 1.87× speedup (2014 seconds → 1075 seconds). The overall speedup from 16 to 64 containers reaches 3.6×, with sublinear scaling indicating growing communication and synchronization overheads at higher scales. 5.4.2 RQ5: Sensitivity Analysis. Figure 5 shows that selecting too few features leads to poor performance due to information loss. Performance improves with more features, stabilizing around 500. Beyond this threshold, adding features introduces noise (e.g., Photo at 700 features). We set the feature count to 500 across all datasets.
GraphFAS : A Distributed System for Automated Graph Feature Generation and Selection in Industrial Transaction Networks
CIKM ’26, November 07–11, 2026, Rome, Italy
Table 4: Node classification accuracy on public benchmarks (%). Cora
CiteSeer
PubMed
DBLP
Computers
Photo
Flickr
LR LGBM MLP GCN SAGE GAT SGC GIPA
76.34±1.33 76.57±1.31 86.94±0.99 88.15±1.09 88.41±1.24 88.30±0.55 87.49±0.82 86.75±1.26
71.41±0.88 71.92±1.72 71.68±1.81 76.61±0.49 77.08±0.75 76.76±0.86 75.53±0.70 72.85±1.61
87.55±0.57 90.86±0.34 88.23±0.28 89.16±0.61 89.39±0.41 88.11±0.27 87.06±0.30 89.12±0.69
75.10±0.66 75.05±0.46 75.25±0.55 82.17±0.59 83.94±0.29 83.79±0.51 83.19±0.49 84.13±0.60
84.14±0.29 86.38±0.28 85.62±0.45 90.64±0.76 91.44±0.22 91.51±0.53 91.01±1.01 91.57±0.88
92.03±0.27 92.88±0.50 92.16±0.58 93.45±0.78 95.59±0.34 95.11±0.62 93.49±0.28 95.14±0.50
46.62±0.08 46.92±0.12 44.16±0.48 53.13±0.51 53.10±0.65 53.52±1.10 51.13±0.11 53.73±0.93
52.41±0.02 70.40±0.03 57.33±0.37 92.21±0.20 93.11±0.21 92.60±0.17 91.74±0.14 95.91±0.25
PCA RFE F-test MI
67.82±1.20 74.17±1.44 72.47±1.28 71.51±1.14
68.11±1.35 70.03±0.68 71.02±1.43 66.16±1.54
85.12±0.74 90.12±0.30 89.93±0.36 89.67±0.25
74.55±0.36 74.17±0.25 74.95±0.40 70.28±0.41
85.37±0.57 86.88±0.26 85.82±0.58 85.99±0.78
91.28±0.42 92.18±0.50 91.62±0.52 92.03±0.47
46.25±0.06 46.09±0.05 46.02±0.09 45.96±0.08
64.51±0.03 66.32±0.02 65.70±0.02 64.99±0.03
Ours
88.27±1.15
76.19±1.02
92.09±0.30
85.02±0.49
91.54±0.56
95.78±0.38
54.56±0.06
95.82±0.03
Table 5: Fraud detection performance on industrial datasets (AUC-ROC %).
Accuracy (%, )
92.5
Dataset2
Dataset3
GIPA
80.12±1.24
98.03±0.56
95.21±0.88
GraphFAS
86.26±0.83
98.80±0.31
99.90±0.12
Full w/o GFG w/o GS
Training Time on DBLP Training Time on Computers Training Time on Photo
90.0 87.5 85.0 82.5 80.0
12 10 8 6 4
77.5
2 DBLP Computers Photo Figure 6: Ablation study across different datasets. Left y-axis: accuracy; right y-axis: log2 (training time). 5.4.3 RQ6: Module Effectiveness. Figure 6 presents the ablation study (training time measured on a single 64-core Intel Xeon E52682 v4 CPU). “w/o GFG” removes the Graph Feature Generation; “w/o FS” removes the Feature Selection. The full model provides the best overall trade-off between performance and runtime. The full model significantly outperforms “w/o GFG” across all datasets, underscoring the critical importance of graph features. On Computers, GraphFAS (91.54%) achieves comparable accuracy to “w/o FS” (90.89%) but with over 10× speedup, demonstrating the FS module’s effectiveness in eliminating irrelevant features without sacrificing predictive performance.
6
2. Graph Mining GraphFAS performs offline feature generation and selection
Business
Training Time (log2 t, )
95.0
Dataset1
1. Seed Selection Business experts define target nodes
Deployment and Industrial Impact
GraphFAS has been deployed in production for over two years, handling millions of seed nodes daily across multiple risk control scenarios. The operational workflow (Figure 7) comprises: (1)
3. Validation Experts verify feature stability and performance
4. Deployment Valid features are registered in the feature store for inference
Real-time Model Inference
Experts
Figure 7: Operational workflow: from seed selection to production deployment Seed Selection—experts define target nodes; (2) Graph Mining— GraphFAS performs offline feature generation and selection; (3) Validation—experts verify feature stability; (4) Deployment—features are registered for real-time inference. In a representative cash-out fraud detection scenario, GraphFAS utilized credit relations and fraud model scores to identify high-risk graph patterns. Quantitatively, the identified features achieved a tenfold lift in uncovering latent fraud groups compared to baseline methods. Furthermore, by automating the discovery process, GraphFAS reduced the feature engineering cycle by over 10× in our deployment compared to traditional manual assessment.
7
Conclusion
We present GraphFAS, a distributed graph feature selection system that provides a practical alternative to end-to-end GNN pipelines under industrial constraints for interpretability and scalability. By combining non-parametric graph feature generation with a distributed Boruta-style selection using median aggregation across partitions, GraphFAS produces explicit, interpretable structural features compatible with native TreeSHAP explainability. Deployed at Alipay for two years, processing millions of seed nodes daily, it outperforms GNN-based approaches while achieving order-ofmagnitude efficiency gains over manual feature engineering. Decoupling feature generation from model training sacrifices some representational capacity in exchange for practical benefits, including CPU-only execution with scalable distributed processing, audit-compliant structural statistics, and flexible downstream model updates without regenerating features.
CIKM ’26, November 07–11, 2026, Rome, Italy
8
GenAI Usage Disclosure
During the preparation of this work, we used Claude Code to assist with code development and manuscript writing. Specifically, the AI tool was utilized to generate boilerplate code, assist with implementation details, draft and polish text, and improve overall language clarity. All AI-generated content was thoroughly reviewed, verified, and refined by the authors. We assume full responsibility for the correctness of the code, the accuracy of the scientific claims, and the ultimate integrity of this work. The core research ideas, experimental design, data analysis, and scientific conclusions were entirely conceived and executed by our human authors.
References [1] Aisha Abdallah, Mohd Aizaini Maarof, and Anazida Zainal. 2016. Fraud detection system: A survey. Journal of Network and Computer Applications 68 (2016), 90–113. [2] Abdulalem Ali, Shukor Abd Razak, Siti Hajar Othman, Taiseer Abdalla Elfadil Eisa, Arafat Al-Dhaqm, Maged Nasser, Tusneem Elhassan, Hashim Elshafie, and Abdu Saif. 2022. Financial fraud detection based on machine learning: a systematic literature review. Applied Sciences 12, 19 (2022), 9637. [3] Kenza Amara, Zhitao Ying, Zitao Zhang, Zhichao Han, Yang Zhao, Yinan Shan, Ulrik Brandes, Sebastian Schemm, and Ce Zhang. 2022. GraphFramEx: Towards Systematic Evaluation of Explainability Methods for Graph Neural Networks. In The First Learning on Graphs Conference. [4] Jeongwhan Choi, Woosung Kang, Minseo Kim, Jongwoo Kim, and Noseong Park. 2025. Can TabPFN Compete with GNNs for Node Classification via Graph Tabularization? arXiv:2512.08798 [cs.LG] https://arxiv.org/abs/2512.08798 [5] Dmitry Eremeev, Gleb Bazhenov, Oleg Platonov, Artem Babenko, and Liudmila Prokhorenkova. 2025. Turning Tabular Foundation Models into Graph Foundation Models. In New Perspectives in Graph Machine Learning. [6] Dmitry Eremeev, Oleg Platonov, Gleb Bazhenov, Artem Babenko, and Liudmila Prokhorenkova. 2025. GraphPFN: A Prior-Data Fitted Graph Foundation Model. arXiv:2509.21489 [cs.LG] https://arxiv.org/abs/2509.21489 [7] C Lee Giles, Kurt D Bollacker, and Steve Lawrence. 1998. CiteSeer: An automatic citation indexing system. In Proceedings of the third ACM conference on Digital libraries. [8] Aditya Grover and Jure Leskovec. 2016. node2vec: Scalable Feature Learning for Networks (KDD ’16). Association for Computing Machinery, New York, NY, USA, 855–864. doi:10.1145/2939672.2939754 [9] William L. Hamilton, Rex Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs. In Proceedings of the 31st International Conference on Neural Information Processing Systems (Long Beach, California, USA) (NIPS’17). Curran Associates Inc., Red Hook, NY, USA, 1025–1035. [10] Adrian Hayler, Xingyue Huang, İsmail İlkan Ceylan, Michael Bronstein, and Ben Finkelshtein. 2025. Bringing Graphs to the Table: Zero-shot Node Classification via Tabular Foundation Models. In New Perspectives in Graph Machine Learning. [11] Javier Martın Hernández and Piet Van Mieghem. 2011. Classification of graph metrics. Delft University of Technology: Mekelweg, The Netherlands 1 (2011). [12] David W Hosmer Jr, Stanley Lemeshow, and Rodney X Sturdivant. 2013. Applied logistic regression. John Wiley & Sons. [13] Yue Jin, Yongchao Liu, and Chuntao Hong. 2025. GraphGen+: Advancing Distributed Subgraph Generation and Graph Learning On Industrial Graphs. In 20th European Conference on Computer Systems. [14] Guolin Ke, Qi Meng, Thomas Finley, Taifeng Wang, Wei Chen, Weidong Ma, Qiwei Ye, and Tie-Yan Liu. 2017. LightGBM: A Highly Efficient Gradient Boosting Decision Tree. In Advances in Neural Information Processing Systems, I. Guyon, U. Von Luxburg, S. Bengio, H. Wallach, R. Fergus, S. Vishwanathan, and R. Garnett (Eds.), Vol. 30. Curran Associates, Inc. [15] Thomas N. Kipf and Max Welling. 2017. Semi-Supervised Classification with Graph Convolutional Networks. In Proc. of ICLR.
Yice Luo et al. [16] Miron B. Kursa and Witold R. Rudnicki. 2010. Feature Selection with the Boruta Package. Journal of Statistical Software 36, 11 (2010), 1–13. doi:10.18637/jss.v036. i11 [17] Houyi Li, Zhihong Chen, Zhao Li, Qinkai Zheng, Peng Zhang, and Shuigeng Zhou. 2023. GIPA: A General Information Propagation Algorithm for Graph Learning. In Database Systems for Advanced Applications: 28th International Conference, DASFAA 2023, Tianjin, China, April 17–20, 2023, Proceedings, Part IV. 465–476. [18] Oumaima Lifandali, Zouhair Chiba, Noreddine Abghour, Khalid Moussaid, Mounia Miyara, and Abdellah Ouaguid. 2025. Performance Enhancement of Intrusion Detection System in Cloud by Using Boruta Algorithm. ACM Trans. Priv. Secur. (2025). doi:10.1145/3736761 Just Accepted. [19] Yongchao Liu, Houyi Li, Guowei Zhang, Xintan Zeng, Yongyong Li, Bin Huang, Peng Zhang, Zhao Li, Xiaowei Zhu, Changhua He, and Wenguang Chen. 2023. GraphTheta: A Distributed Graph Neural Network Learning System With Flexible Training Strategy. Technical report (2023). [20] Scott M. Lundberg, Gabriel G. Erion, and Su-In Lee. 2018. Consistent Individualized Feature Attribution for Tree Ensembles. CoRR abs/1802.03888 (2018). [21] Dongsheng Luo, Wei Cheng, Dongkuan Xu, Wenchao Yu, Bo Zong, Haifeng Chen, and Xiang Zhang. 2020. Parameterized explainer for graph neural network. In Proceedings of the 34th International Conference on Neural Information Processing Systems. Article 1646, 12 pages. [22] G. Manikandan, B. Pragadeesh, V. Manojkumar, A.L. Karthikeyan, R. Manikandan, and Amir H. Gandomi. 2024. Classification models combined with Boruta feature selection for heart disease prediction. Informatics in Medicine Unlocked 44 (2024), 101442. [23] Bryan Perozzi, Rami Al-Rfou, and Steven Skiena. 2014. DeepWalk: online learning of social representations. In Proceedings of the 20th ACM SIGKDD International Conference on Knowledge Discovery and Data Mining. 701–710. [24] Prithviraj Sen, Galileo Namata, Mustafa Bilgic, Lise Getoor, Brian Galligher, and Tina Eliassi-Rad. 2008. Collective classification in network data. AI magazine (2008). [25] Lloyd S. Shapley. 1951. Notes on the n-Person Game – II: The Value of an n-Person Game. RAND Corporation (Aug 1951). [26] Oleksandr Shchur, Maximilian Mumme, Aleksandar Bojchevski, and Stephan Günnemann. 2018. Pitfalls of graph neural network evaluation. arXiv preprint arXiv:1811.05868 (2018). [27] Sheng Tian, Xintan Zeng, Yifei Hu, Baokun Wang, Yongchao Liu, Yue Jin, Changhua Meng, Chuntao Hong, Tianyi Zhang, and Weiqiang Wang. 2024. GraphRPM: Risk Pattern Mining on Industrial Large Attributed Graphs. In Machine Learning and Knowledge Discovery in Databases. Applied Data Science Track. [28] Petar Veličković, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Liò, and Yoshua Bengio. 2018. Graph Attention Networks. In Proc. of ICLR. [29] Huanjing Wang, Qianxin Liang, John T Hancock, and Taghi M Khoshgoftaar. 2024. Feature selection strategies: a comparative analysis of SHAP-value and importance-based methods. Journal of Big Data 11, 1 (2024), 44. [30] Felix Wu, Amauri Souza, Tianyi Zhang, Christopher Fifty, Tao Yu, and Kilian Weinberger. 2019. Simplifying graph convolutional networks. In International conference on machine learning. Pmlr, 6861–6871. [31] Xiabao Wu, Yongchao Liu, Wei Qin, and Chuntao Hong. 2025. Distributed Graph Neural Network Inference With Just-In-Time Compilation For Industry-Scale Graphs. In 20th European Conference on Computer Systems. [32] Chenxiao Yang, Qitian Wu, Jiahua Wang, and Junchi Yan. [n. d.]. Graph Neural Networks are Inherently Good Generalizers: Insights by Bridging GNNs and MLPs. In The Eleventh International Conference on Learning Representations. [33] Zhilin Yang, William Cohen, and Ruslan Salakhudinov. 2016. Revisiting semisupervised learning with graph embeddings. In Proc. of ICML. [34] Rex Ying, Dylan Bourgeois, Jiaxuan You, Marinka Zitnik, and Jure Leskovec. 2019. GNNExplainer: generating explanations for graph neural networks. In Proceedings of the 33rd International Conference on Neural Information Processing Systems. Article 829, 12 pages. [35] Hanqing Zeng, Hongkuan Zhou, Ajitesh Srivastava, Rajgopal Kannan, and Viktor Prasanna. [n. d.]. GraphSAINT: Graph Sampling Based Inductive Learning Method. In International Conference on Learning Representations. [36] Qinkai Zheng, Houyi Li, Peng Zhang, Zhixiong Yang, Guowei Zhang, Xintan Zeng, and Yongchao Liu. 2021. GIPA: General Information Propagation Algorithm for Graph Learning. ArXiv abs/2105.06035 (2021).