{'fraction_non_alphanumeric': 0.03953496053109621, 'fraction_numerical': 0.010734220695577501, 'mean_word_length': 4.831664098613251, 'pattern_counts': {'":': 0, '<': 0, '<?xml version=': 0, '>': 0, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 4, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
T2G-Former: Organizing Tabular Features into Relation Graphs Promotes Heterogeneous Feature Interaction

Recent development of deep neural networks (DNNs) for tabular learning has largely benefited from the capability of DNNs for automatic feature interaction. However, the heterogeneity nature of tabular features makes such features relatively independent, and developing effective methods to promote tabular feature interaction still remains an open problem. In this paper, we propose a novel Graph Estimator, which automatically estimates the relations among tabular features and builds graphs by assigning edges between related features. Such relation graphs organize independent tabular features into a kind of graph data such that interaction of nodes (tabular features) can be conducted in an orderly fashion. Based on our proposed Graph Estimator, we present a bespoke Transformer network tailored for tabular learning, called T2G-Former, which processes tabular data by performing tabular feature interaction guided by the relation graphs. A specific Cross-level Readout collects salient features predicted by the layers in T2G-Former across different levels, and attains global semantics for final prediction. Comprehensive experiments show that our T2G-Former achieves superior performance among DNNs and is competitive with non-deep Gradient Boosted Decision Tree models.

However, different from images and texts, it is challenging for fusion-based models to handle tabular feature interaction due to the feature heterogeneity problem (Borisov, Leemann et al. 2021). DANets (Chen, Liao et al. 2022) suggested the "selection & abstraction" principle that processes tabular data by first selecting and then interacting the selected features. Known neural feature selection schemes can be categorized into soft and hard versions. The soft selection essentially exerts fully connected interactions among features (see Fig. 1(b)), such as multiplicative interaction (Guo, Tang et al. 2017), feature crossing (Wang, Fu et al. 2017;Wang, Shivanna et al. 2021), and attention-based interaction (Song, Shi et al. 2019;Huang, Khetan et al. 2020;Gorishniy, Rubachev et al. 2021). However, tabular features by nature are heterogeneous, and fully connected interaction is a sub-optimal choice since it blindly fuses all features together. DANets (Chen, Liao et al. 2022) performed hard selection by grouping correlative features and then constraining interactions among grouped features ( Fig.1(c)). Although DANets achieved promising results, its feature selection operation cannot thoroughly address intra-group interactions (see Fig. 1(c)), and thus features assigned in a same group are indiscriminately fused, making the model inferiorly expressive.
There are numerous daily applications that exemplify the significance of selective interaction for heterogeneous tabular features. The left part of Fig. 1 gives an example of a medical data table. Using underlying medical knowledge, a static graph can be formed to indicate relations of reasonable feature pairs. For instance, the relation of height and weight gives a probability representing a high-level semantic physique. Also, the relation between weight and blood pressure (BP) is likely to indicate a semantic cardiovascular health. Besides, there might be some "inert features" that are unrelated to any other features, such as the features representing the level of HIV antibody (HIV-Ab). In the right  part, Fig. 1(a) presents the original tabular features whose relations are not specified, and higher-level semantics cannot be directly obtained if the feature relations are not determined. Fig. 1(b) illustrates the fully connected interactions of soft selection, which may introduce some noisy relations in feature fusion (e.g., the "inert feature" connects with the other features). Hard selection with a grouping operation (e.g., used in DANets) achieves partially selective interactions by grouping related features (see Fig. 1(c)), but is still likely to include noisy interactions. It can only group related features but fails to handle the feature relations within the same group. In Fig. 1(c), the grouping design can only put the features height, weight, and BP together for mutual interactions, but cannot exclude the meaningless height-BP pair. It is intuitive that a precise health condition assessment can be made based on both the data-specific record values (e.g., 173.6 cm for height in Fig. 1) and the underlying knowledge represented by the edges of the relation graph. For the first sample in the medical table (ID = 1), considering the values of height and weight jointly can suggest a symptom of overweight. Similarly, combining the values of weight and BP indicates a risk of cardiovascular problems. The second sample (ID = 2) directly indicates a risk of HIV infection solely based on the feature of HIV-Ab. Hence, we argue that an ideal way to handle such complex decision processes is to build a graph with adaptive edge weights. The edge weights (represented by different colors and widths in Fig. 1(d)) indicate the strengths of relations based on specific feature values, and the static graph topology represents the underlying knowledge to constrain meaningful relations.
Inspired by the above observations, in this paper, we propose to build graphs for tabular features to guide feature interaction. We develop a novel Graph Estimator (GE) for organizing independent tabular features into a feature relation graph (FR-Graph). Further, we present a bespoke Transformer network for tabular learning, called T2G-FORMER, by stacking GE-incorporated blocks for selective feature interaction. GE models an FR-Graph by assembling (i) a static graph topology depicting underlying knowledge of the task and (ii) data-adaptive edge weights for graph edges. The static graph depicts the underlying knowledge (the relations of feature pairs), while the data-adaptive edge weights represent the strengths of relations based on specific feature values. Using the FR-Graph, we can effectively capture more subtle interactions which may be mishandled by grouping strategies (as shown in Fig. 1(c)). In our proposed T2G-FORMER, each layer employs the FR-Graph to transform layer input features into graph data, and heterogeneous feature interactions are performed in an orderly fashion based on the specification of graph edges. Besides, a special Crosslevel Readout collects salient features from each level and attains global tabular semantics for the final prediction.
The workflow of T2G-FORMER proceeds as follows. An FR-Graph, whose edges represent the static relations of features with data-adaptive weights (predicted by the GE module), guides the processing of the tabular feature interaction to predict higher-level features. Then another FR-Graph for higher-level tabular features is built to organize the feature interaction, and the process continues. T2G-FORMER can output comprehensive semantics from different feature levels by repeating the above process. The shared Cross-level Readout is used to aggregate semantics from different feature levels, and takes all these features into consideration in the final prediction.
Overall, the main contributions of our work are as follows: • We first utilize feature relation graphs to handle heterogeneous feature interaction for tabular data, and propose a novel GE module for feature relation organization.
• We adapt feature relation graphs in the Transformer architecture, and build a specialized tabular learning Transformer T2G-FORMER for tabular classification and regression.
Differentiable Tree Models. DNNs of this type (Popov, Morozov, and Babenko 2019;Arik and Pfister 2021;Katzir, Elidan, and El-Yaniv 2020) were inspired by the successes of the ensemble tree frameworks (Kontschieder, Fiterau et al. 2015;Feng, Yu, and Zhou 2018;Yang, Morillo, and Hospedales 2018). NODE (Popov, Morozov, and Babenko 2019) combined differentiable oblivious decision trees (Lou and Obukhov 2017) with multi-layer hierarchical representations and achieved competitive performances as GBDT. TabNet (Arik and Pfister 2021) employed an attention mechanism (Vaswani, Shazeer et al. 2017) to sequentially select salient features for tree-like decision. Net-DNF (Katzir, Elidan, and El-Yaniv 2020) introduced bias of a disjunctive normal form to select and aggregate feature subsets in each block. NODE and Net-DNF largely benefited from model ensembles but did not take advantage of the feature representation capability of DNNs (Chen, Liao et al. 2022). Tab-Net designed non-interactive transformer blocks for feature representation and selection without feature fusion. All these DNNs function as feature selectors and splitters, but neglect underlying interactions among tabular features.

Tabular Feature Interaction
Most of the previous fusion-based work simply transferred successful neural architectures (e.g., MLP (Guo, Tang et al. 2017), self-attention (Song, Shi et al. 2019), and Transformer (Huang, Khetan et al. 2020;Gorishniy, Rubachev et al. 2021)) into tabular data and interacted features with soft selection. However, feature heterogeneity (Borisov, Leemann et al. 2021;Popov, Morozov, and Babenko 2019) led to gap of inductive bias and made these models (which were designed for homogeneous data, e.g., images and texts) sub-optimal. DANets (Chen, Liao et al. 2022) first adapted selective feature interaction by hard selection, constraining interactions in a feature group, and achieved promising results; but, relations of intra-group features were still not managed well. Hence, this paper proposes feature relation graphs and adapts them into a tailored Transformer network.

Graph Estimator
We propose Graph Estimator (GE) (Fig. 2(b)) for automatically building Feature Relation Graphs (FR-Graphs), which treats tabular features as nodes in a graph and estimates the feature relations as edges. The GE design is inspired by knowledge graph completion (KGC) (Shi and Weninger 2018;Wu, Chen et al. 2021) that might use semantical similarity of two entities to estimate their relation plausibility. A basic form to measure semantical similarity (Nickel, Tresp, and Kriegel 2011) is: where h, t ∈ R n are an encoded head entity node and a tail one, and a learnable matrix M r ∈ R n×n represents relation r in a knowledge graph (KG). Various following methods (Yang, Yih et al. 2015;Trouillon, Welbl et al. 2016;Nickel, Rosasco, and Poggio 2016) followed this idea, which differed from one another solely in relation embeddings and score functions. Different from KGC models that only compute static relation plausibility for entities, GE estimates the feature relations by a static underlying graph topology with dataadaptive edge weights. We take each tabular feature as a node, and first perform semantic matching to estimate the soft plausibility of pair-wise interactions between tabular features, which are referred to as data-adaptive edge weights in this section. Second, a static knowledge topology is learned based on tabular column semantics to preserve interactions of salient feature pairs. At the end, edge weights are assembled with the knowledge topology to form an FR-Graph.

FR-Graph Structure Components
To mine the relations among tabular features, we build FR-Graph by treating tabular features as graph node candidates and predicting the edges among them. The edges were yielded from two perspectives: adaptive edge weights representing data-specific information, and static edge topology for all the data representing the underlying knowledge. Note that some features are isolated from the FR-Graph if no other nodes connected with them.
Adaptive Edge Weights. Given two tabular feature embedding vectors x i , x j ∈ R n (i, j ∈ {1, 2, . . . , N }), where N is the number of input features (table columns), we evaluate their interaction plausibility using the following pairwise score function: where two learnable parameters W h , W t ∈ R m×n denote transformations for a head feature and a tail one, and diag(r) ∈ R n×n is a diagonal matrix parameterized by learnable relation vectors r ∈ R n that semantically represent feature interaction relations. Here W h and W t share parameters if the pair-wise feature edge weights are symmetric (i.e., G w [i, j] ≡ G w [j, i]) and are parameter-independent in the asymmetric case (i.e., G w [i, j] = G w [j, i]). All bias vectors are omitted for notation brevity. Consequently, the adaptive weight scores g w of all feature pairs constitute a fully connected weighted relation graph G w . Note that the edge weight score is degraded to an attention score when r is filled with scalar value 1 (and diag(r) becomes an entity matrix), and thus it is able to measure weighted feature similarity.
Static Knowledge Topology. Although we introduce soft edge weights for all feature pairs, it is also important to globally consider the underlying knowledge of the tabular data. Thus, we use a series of column embeddings to represent the semantics of the tabular features, and a static relation topology score can be computed as follows: E t } is learnable column embeddings categorized into the head view or tail view, E = (e 1 , e 2 , . . . , e N ) ∈ R d×N , and d is the embedding dimension. Similarly, the relation topology score g t has the symmetric and asymmetric counterparts, and E h and E t share parameters in the symmetric relation topology (i.e., . We use L 2 normalization in the g t score function to transform embeddings to be on a similar scale and improve the training stability. We generate static relation topology based on the G t scores in Eq. (4), as: where σ 1 is an element-wise activation parameterised by a learnable bias b (like the operation in PReLU (He, Zhang et al. 2015)), G t is adjacency matrix scores composed of the relation topology score g t , T is a constant threshold for signal clipping, and 1 denotes the indicator function. In this way, we obtain a global graph topology (an adjacency matrix A) to constrain feature interactions, and this topology can be regarded as static knowledge on the whole task.

Relation Graph Assembling
As we obtain "soft" adaptive edge weights from the data view and "hard" static relation graph topology from the knowledge view, we combine them to generate an FR-Graph, following the idea of "decision on both specific data and underlying knowledge". Specifically, we assemble the two components as follows: where σ 2 is a competitive activation (e.g., L p normalization, softmax, entmax, sparsemax (Martins and Astudillo 2016)) to restrict the indegree of each "feature node", and denotes the Hadamard product. The resulted relation graph G is a weighted graph based on both adaptive feature matching and static knowledge topology. To help the FR-Graph focus on learning meaningful interactions between different features, a "no-self-interaction" function f nsi is performed to explicitly exclude self-loops in G. We use the FR-Graph to instruct subsequent feature interactions. Since both the edge weights and knowledge topology have the symmetric and asymmetric versions, there are four combinations of FR-Graph covering the complete relation graph. In experiments, we will further discuss the impact of the FR-Graph type.

T2G-FORMER
We incorporate GE into the attention-like basic block, and build T2G-FORMER by stacking multiple blocks for selective tabular feature interaction (see Fig. 2). T2G-FORMER uses estimated FR-Graphs to interact features and attain higher-level features layer by layer. A Cross-level Readout is sequentially transformed to the feature space of each layer, and selectively collects salient features for the final prediction. A shortcut path is added to preserve the information from the preceding layers, resulted in gated fusion in different feature levels that promotes the model capability.

Basic Block
A single block is built equipped with GE for selective feature interaction (see Fig. 2(b)). Given input features X l ∈ R n×N to the l-th layer, we obtain higher-level features X l+1 as follows: where W v ∈ R m×n is learnable parameters for feature transformation, and V l is transformed input features. FFN denotes a feed-forward network. As self-interaction is excluded in G l (see Eq. (6)), a shortcut path g is added to protect the information from the preceding layers, which is a simple dropout layer in experiments. Notably, we yield and use the FR-Graph for feature interactions, and does not influence the intra-feature update conducted by the shortcut. In the first layer, we set X 0 as the input tabular data encoded by a simple feature tokenizer (Gorishniy, Rubachev et al. 2021). In this way, higher-level features can be iteratively obtained with the generated FR-Graphs and selective interaction. In implementation, layer normalization is performed (see Fig. 2(b)) for stable training.

Cross-level Readout
We design a global readout node to selectively collect salient features from each layer and attain comprehensive semantics for the final prediction. Specifically, we attentively fuse selected features at the current layer and combine them with the lower-level features from the preceding layers by a shortcut path. Given the current readout status z l ∈ R n , the collection process at the l-th layer is defined by: where α l i denotes the weight of the i-th feature that constitutes a weight vector α l ∈ R N , e l ∈ R d is a learnable vector representing the semantics of the readout node at the l-th layer, f t i is an encoded feature (Eq. (3)) of each layer, and e t i is a layer-wise column embedding (Eq. (4)). V l is the transformed input features (Eq. (7)). Here we put z l forward through the same FFN transformation to transform the current readout into the feature space at the (l + 1)-th layer for the next round of collection. The shortcut paths are directly added without information drop. This collection process is repeated from the input features to the highest-level features, thus encouraging interactions among cross-level features.

The Overall Architecture and Training
Basic blocks are stacked in T2G-FORMER ( Fig. 2(a)). If without special specification, in experiments we use 8-head GE in each block by default ( Fig. 2(b)). Prediction is made based on the readout status after processing the final layer L, as:ŷ = FC(ReLU(LN(z L ))), where LN and FC denote layer normalization and a fully connected layer, respectively. As for optimization, we use the cross entropy loss for classification and the mean squared error loss for regression, as in previous DNNs. We tested various tasks and observed that continuing to optimize the static graph topology A in Eq. (5) across the whole training phase may lead to unstable performance on some easy tasks (e.g., binary classification, small datasets, or few input features). Thus, we freeze it after convergence for further training in a fixed topology manner. Note that we introduce additional hyperparameters d (Eq. (4)) and T (Eq. (5)). In experiments, we adaptively set d = 2 log 2 N which is for the minimal amount of information to present an adjacency matrix with N 2 binary elements, and keep T = 0.5 across all the datasets. We choose sigmoid as σ 1 and softmax as σ 2 . Straight-through trick (Bengio, Léonard, and Courville 2013) is used to solve the undifferentiable issue of the indicator function in Eq. (5).

Experiments
In this section, we present extensive experimental results and compare with a wide range of state-of-the-art tabular learning DNNs and GBDT. Also, we conduct empirical experiments to examine the impacts of some key T2G-FORMER components, including comparison of the feature relation graph (FR-Graph) types, ablation study of self-interaction, and the effect of GE. Besides, we explore the model interpretability by visualizing the FR-Graphs and readout selection on two semantically rich datasets.
Implementation Details. We implement our T2G-FORMER model using PyTorch on Python 3.8. All the experiments are run on NVIDIA GTX 3090. In training, if without special specification, we use FR-Graphs with symmetric edge weights and asymmetric graph topology in GE. The optimizer is AdamW (Loshchilov and Hutter 2018) with the default configuration except for the learning rate and weight decay rate. For DANet-28, we follow its QHAdam optimizer (Ma and Yarats 2018) and the pre-set hyperparameters given in (Chen, Liao et al. 2022) without tuning. For the other DNNs and XGBoost, we follow the settings provided in (Gorishniy, Rubachev et al. 2021) (including the optimizers and hyperparameter spaces), and perform hyperparameter tuning with the Optuna library (Akiba, Sano et al. 2019) and grid search (only for NODE). More detailed information of hyperparameters is provided in Appendix B.

Main Results and Analyses
Performance Comparison. The performances of the DNNs and non-deep models are reported in Table 2. T2G-FORMER outperforms these DNNs on nine datasets, and is comparable with XGBoost in most the cases. All the models are hyperparameter-tuned by choosing the best validation results with Optuna-driven tuning (Akiba, Sano et al. 2019).
The Effect of FR-Graph Types. We compare four types of FR-Graphs in GE. Table 3 reports the results, from which one can see that it is often better to choose symmetric edge weights and asymmetric knowledge topology. This suggests that mutual interactions between two tabular features are likely to be the same, and asymmetric topology offers a larger semantic exploration space that is more likely to yield useful features. The results on the other datasets are provided in Appendix C.
The Effect of Self-interaction. One of our key designs in GE is the "no self-interaction function" that explicitly excludes self-loops in FR-Graphs. Table 4 reports comparison results on several datasets with no self-loop FR-Graphs (ours) and self-loop FR-Graphs. The results show that in most the cases, removing self-loops and focusing on interactions with other features slightly benefit performances in both classification and regression. This may be because feature self-interaction affects the probabilities of interactions with other features (as we use competitive activation in Eq. (6)), while our shortcut paths have already preserved self-information.
The Effect of GEs. We explore the impact of including GEs at different layers of T2G-FORMER. Table 5 reports the performances of different model versions which differ solely in the positions and numbers of GEs used. As for the layers without GE, we use the ordinary attention score for substitution. Overall, the positions of GEs show bigger influence on regression tasks than on classification tasks. As one can see, in regression tasks, the model incurs larger performance drops when GEs are equipped in higher layers, while the drops do not seem so large related to GE positions in classification. Also, the model equipped with only attention score is better than the one with a single GE in a high layer (not in the first layer) for regression tasks, but is always sub-optimal in classification tasks. A probable explanation is that regression needs a smoother optimization space than classification, and thus the fully connected attention score provides the kind of interactions to cope with continuous feature values, while a single GE in a high layer is difficult to capture clear relations among features fused in the fully connected manner. Therefore, it is better to completely use attention score than a single GE in a high layer for regression. A single GE in the first layer shows the least performance drop in both regression and classification, which can be explained by the strength of GE in capturing underlying relations among tabular features with clear semantics.
In summary, the removal of GE in any layers is likely to cause performance drop, and the best results are achieved by applying GE to all the layers.
Comparison of Topology Learning Approaches. Apart from the column embedding approach proposed in Sec. 3.1, there are some other intuitive straightforward approaches to get knowledge topology of the RF-Graph, for example, performing threshold clipping on the adaptive edge weights directly (we call it "adaptive topology") or learning an N -by-N adjacency matrix (we call it "free topology"). Concretely, for learning adaptive topology, we substitute G t in Eq. (5)  Table 1: Some details of the 12 public datasets. "RMSE" denotes root mean squared error (for regression), and "Acc." means accuracy (for classification). The number following each "+" in the row of "# features" is the number of categorical features.  For standard deviations, see Appendix C. For each dataset, the top performances among the DNNs are marked in bold, and the second best results are underlined. We also report XGBoost results as a typical representation of GBDT models. ↓ represents the RMSE metric (the lower the better) and ↑ represents accuracy (the higher the better).  Table 3: Comparison of four FR-Graph types on several tasks and datasets. "A" means asymmetric, and "S" means symmetric. "A w S t ", for example, is for asymmetric edge weights and symmetric graph topology. Likewise, "A w A t ", "S w S t ", and "S w A t " denote the other three types of FR-Graphs. The performances on the CA dataset are scaled (×100) in these several tables for more clear comparison.
with G w in Eq.
(2). For learning the free topology, we directly represent G t by an N -by-N matrix. Table 6 reports the comparison results of these topology learning strategies.
One can see that, the static knowledge topology shared on the whole dataset (our approach) attains superior performances than the adaptive topology, implying the plausibility of our underlying knowledge assumption mentioned in Sec. 1. Besides, the completely free topology also achieves inferior performances, which is probably because of the excessive freedom given to the learnable matrix.
Comparison with DANet Grouped Interactions. As illustrated in Fig. 1, DANets (Chen, Liao et al. 2022) interacted tabular features in the group determined by the "entmax" operation. Here we compare our graph-based inter-  Table 4: Comparison of the effects of FR-Graphs without (w/o) self-loops and FR-Graphs with self-loops. "SL" means self-loops.
action with that group-based one to inspect the benefits of FR-Graph. Specifically, we substitute the knowledge topology A in Eq. (5) with DANet grouped selection mask. The results in Table 7 suggest that it of greater benefits to organize tabular features into a graph, since a graph topology is able to capture relation edges and provide more subtle interactions than a group structure.

Interpretability
In Fig. 3, we visualize the first-layer FR-Graph and the readout collecting strategy on the input features (i.e., features from the feature tokenizer; see Fig. 2(a)). On the CA dataset, it is reasonable to find that the median income (MedInc, MI) of the residents within a block group is related to the average number of the household members (AveOccup, Av-Occ), and AveOccup can affect the average number of bedrooms (AveBedrooms, AvB). Also, there appear to be some relations such as Longitude (Long)-HouseAge (HoA), Longitude-AveRooms (AvR), and Longitude-Population (Pop), which are probably derived from dataset bias. As for read-  Table 5: Performances of including GEs in different layers of T2G-FORMER. All the results are obtained with a 3-layer T2G-FORMER. "# i" means that only the i-th layer has GE while the other layers replace GE with the ordinary attention score, "All" means that all the layers are equipped with GE, and "None" means that all the layers use ordinary attention.  out, one can see that solely HouseAge is collected that is a meaningful feature in house price prediction. On the CH dataset, there are reasonable relations between Balance (Bal, bank balance of a customer) and EstimatedSalary (EstSal), as well as the age of the customer (Age) and Estimated-Salary. Also, it is interpretable that the credit score of a customer (CreditScore, CrSc) is highly related to that customer's Age and Balance. The readout collects only Age in the current level for predicting whether a customer will leave the bank, which is intuitive as well.

Conclusions
In this paper, we proposed T2G-FORMER, a new bespoke Transformer model for tabular learning with a novel module Graph Estimator (GE) for promoting heterogeneous feature interaction based on estimated relation graphs. We adapted feature relation graphs into the basic blocks of T2G-FORMER in an attention-like fashion for simplicity and applicability. Experiments on extensive public datasets showed that T2G-FORMER achieves better performances than various DNNs and is comparable with XGboost. We expect that our T2G-FORMER will serve as a strong baseline in tabular learning studies and enhance research interest in handling feature heterogeneity of tabular data.

A Dataset Descriptions
Details of used datasets are shown in Table 8. We follow the same train-valid-test splits and data pre-processing methods in (Gorishniy, Rubachev et al. 2021;Gorishniy, Rubachev, and Babenko 2022).

B Hyperparameter Tuning
For baseline architectures of XGBoost, MLP, SNN, TabNet, NODE, AutoInt, DCNv2 and FT-Transformer, we reuse the implementations and hyperparameter search spaces in (Gorishniy, Rubachev et al. 2021) for comparison. For DANets we use 28-layer architecture and corresponding pre-set hyperparameters as (Chen, Liao et al. 2022) recommended without tuning. We use grid search for NODE. For our T2G-FORMER, we use the optuna-driven tuning (Akiba, Sano et al. 2019) with hyperparameter spaces reported in Table  9. we also use the optuna-driven tuning (Akiba, Sano et al. 2019) for the rest methods.

C Detailed Experiment Results
Table 10 reports detailed performance results (with standard deviations) of all models on all the datasets. Table 11 reports detailed results in "FR-Graph combinations". Table 12 shows detailed descriptions of features in dataset CA and CH. The CA dataset is typically used for predicting house price in California, while the CH is often used for predicting whether the customer will leave the bank.