Pith. sign in

REVIEW 2 major objections 5 minor 37 references

Rel-HNN: Split Parallel Hypergraph Neural Network for Learning on Relational Databases

T0 review · 2 major / 5 minor · reviewed 2026-08-06 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read A hypergraph that makes one node per column-value pair and one hyperedge per tuple outperforms graph baselines on relational learning benchmarks.

desk verdict The leakage in Algorithm 1 is real: the label column is built into the hypergraph, so the reported accuracy gains are not trustworthy; the split-parallel training idea may still be salvageable. read the letter →

arxiv 2507.12562 v1 pith:V44XN6OX submitted 2025-07-16 cs.DB cs.DCcs.LG

Md. Tanvir Alam , Md. Ahasanul Alam , Md Mahmudur Rahman , Md. Mosaddek Khan This is my paper
classification cs.DBcs.DCcs.LG
keywords hypergraphneuralnetworkrelationaldatabaselearningattribute-valuemulti-GPUtrainingtableembeddingclassificationandregressionsplit-parallelschema-agnosticrepresentation
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

The paper proposes rel-HNN, a hypergraph neural network for relational databases that creates one node per unique attribute-value pair and one hyperedge per tuple. The model alternates message passing between nodes and hyperedges, with optional learnable per-table embeddings, and is trained end-to-end to predict a target column. On nine classification datasets it reports higher AUROC than GCN, GAT, SPARE, and ATJ-Net on eight, and on four regression datasets it reports lower RMSE across the board. A node-partitioned multi-GPU variant reduces per-epoch training time by up to 3.18x on relational data and 2.94x on benchmark hypergraphs. The paper's claim is that attribute-level hypergraph structure, not schema engineering, is what drives these gains.

What carries the argument

The load-bearing object is the attribute-value hypergraph: for every table, every row, and every column, a node is created for the pair (column name, cell value), and each row then becomes a hyperedge connecting the nodes of its cells. This turns the schema into an unlabeled incidence structure, so no primary-key/foreign-key extraction is needed and shared values across tables become shared nodes. On this hypergraph, rel-HNN runs two-phase message passing: hyperedge embeddings are sums of node embeddings passed through an MLP, node embeddings are sums of incident hyperedge embeddings passed through another MLP, and optional per-table embedding vectors are concatenated to the hyperedge embeddings to inject global context. The split-parallel algorithm factorizes the hyperedge MLP into a linear part computed locally per GPU plus a nonlinear activation applied after cross-GPU summation of partial hyperedge sums.

What would settle it

Run the released code with the target column removed from the attribute-value node construction, or inspect the code to see whether it is already excluded; if the AUROC and RMSE gaps against ATJ-Net vanish or shrink substantially, the empirical advantage is leakage rather than representation.

Watch

Extended reading notes

Core claim

The central claim is that representing each attribute-value pair as a node and each tuple as a hyperedge lets a hypergraph neural network learn richer representations than tuple-as-node graphs, because intra-tuple associations are preserved as hyperedges rather than flattened into pairwise edges. Rel-HNN learns embeddings at three levels: attribute-value nodes, tuple hyperedges, and table embeddings, and uses two-phase message passing that first aggregates nodes into hyperedges and then aggregates hyperedges back into nodes. The paper further claims that splitting the node set across GPUs and exchanging partial hyperedge sums yields near-lossless speedups. Empirically it reports state-of-the-art AUROC on eight of nine classification datasets and lower RMSE on all four regression datasets, with the largest gains on datasets with many tables and columns.

Load-bearing premise

Algorithm 1 builds hypergraph nodes from every column of every table, including the target label column, so during training each row's hyperedge contains a node that encodes the true label and that node's embedding can be read off to make the prediction.

Editorial extensions

If this is right

  • Because the representation treats every column uniformly, the method can be applied to a database without extracting primary-key/foreign-key constraints or doing manual feature engineering.
  • Hyperedge-level message passing captures co-occurrence of attribute-value pairs inside a tuple, which tuple-as-node graph models do not represent directly.
  • Explicit per-table embeddings add global context and appear to help most on schemas with many tables; on shallow schemas the non-table variants are competitive.
  • The split-parallel training reduces per-epoch time on large hypergraphs, while communication overhead can erase the benefit on small datasets.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • If the target column is included in Algorithm 1's node construction, then each training row's hyperedge contains a node encoding the true label, and the final hyperedge embedding used for prediction is a function of that node; the reported accuracy gains could then be explained by label leakage rather than by the representation.
  • A clean test would rerun the experiments with the target column excluded from node construction; the speedup results would be unaffected, but the AUROC and RMSE comparisons would likely change substantially.
  • The split-parallel scheduler is orthogonal to the hypergraph representation and could be applied to other hypergraph neural networks, making the speedup claim the more robust contribution if the accuracy claim is confounded.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

2 major / 5 minor

Summary. This paper proposes rel-HNN, a hypergraph neural network for supervised learning on relational databases. The method builds a hypergraph in which each unique attribute-value pair is a node and each tuple is a hyperedge, and it learns embeddings at attribute-value, tuple, and table levels via alternating node-to-hyperedge and hyperedge-to-node message passing. A split-parallel multi-GPU training algorithm is introduced for scalability. The empirical sections report AUROC and RMSE comparisons on nine classification and four regression datasets, as well as training-time speedups. The central claim is that rel-HNN significantly outperforms state-of-the-art graph- and hypergraph-based methods on both tasks.

Significance. If the reported results were valid, the paper would make a useful contribution: the attribute-value hypergraph representation is schema-agnostic, avoids flattening, and the split-parallel algorithm addresses a real scalability need for hypergraph neural networks. The paper also provides a code repository link and reports detailed dataset statistics, which are strengths. However, the evaluation is undermined by a fundamental design issue: Algorithm 1 appears to place the target label column into the input hypergraph, so each training hyperedge contains the true label as one of its nodes. As written, the accuracy and RMSE improvements in Tables 3 and 5 are explainable by label leakage rather than by the proposed architecture. A major revision that excludes the label column from hypergraph construction and re-runs the experiments would be needed before the central claim can be assessed.

major comments (2)
  1. [4.1, Algorithm 1; Equations (2)-(5); Tables 3 and 5] Algorithm 1 creates a node for every unique attribute-value pair in every column of every table, including the target table's label column. For each training row i of the target table, the node (label, y_i) is therefore included in hyperedge e_i. Equation (2) forms the initial hyperedge embedding as an MLP over the sum of the node embeddings in e_i, and Equations (4) and (5) propagate this signal through all layers; the text then states that Z^L_e for target-table hyperedges is the predicted class probability. Thus the true label is an input feature, not merely a supervision signal. The manuscript never states that the label column is excluded from Algorithm 1 or from the feature encodings in Section 4.1, and Section 5 reports no experiment that removes the label column. Unless the implementation silently omits the target column, the large AUROC improvements in Table 3 and the 90%+ RMSE reductions in Table 5 are explained by label leakage rather than by the proposed representation. This is the load-bearing support for the paper's central claim.
  2. [Section 2 and Algorithm 1] The task is defined as predicting labels for rows of the target table where the label is unknown, but Algorithm 1 builds a hyperedge for every row from all of its columns. For test rows, either the label values are present in the input, which is leakage, or they are absent, in which case test hyperedges have a different set of nodes than training hyperedges and the model's input distribution changes. The manuscript does not describe how missing target labels are handled during hypergraph construction or inference, so the reported train/test protocol is ambiguous and the experimental comparison cannot be interpreted as a standard supervised-learning evaluation.
minor comments (5)
  1. [Algorithm 2, line 15] The update step omits MLP^0_V and MLP^0_E from the parameter sets, even though these MLPs are used in lines 5-8 and are included in the initialization in line 2; if this is a typo, correct it, and if it is intentional, explain why the first-layer projections are not trained.
  2. [Table 3, ATJ-net row] The entries for SameGen, st_loan, and Mutag are concatenated into '0.50300.94110.8812'; fix the formatting so each value is separately readable.
  3. [Section 4.3, Equations (6)-(9)] The text refers to an undefined 'Equation??', and Equations (7) and (9) sum from i=0 to N even though there are N GPUs; the index range should presumably be i=1 to N.
  4. [References] Reference [9] is a duplicate of reference [8]; the duplicated citation should be removed or replaced.
  5. [Section 5.1, experimental settings] The statement that the embedding length of all nodes and hyperedges is 'fixed at two' is unexpectedly small; clarify whether this is literally 2 or a shorthand for a larger dimension, since such an embedding size would likely be too small for the reported tasks.

Circularity Check

1 steps flagged · score 9.0 of 10

Algorithm 1 includes the target label column as input nodes, so rel-HNN's 'predicted' class probability is a function of the true label; the reported gains reduce to label leakage.

  1. self definitional [Section 4.1, Algorithm 1; Section 4.2, text after Eq. (5)]
    "we create a node for each unique attribute-value pair, (Attr_k^j, T_{k,i,j}), found in all the tables contained by the database (Algorithm 1, Lines 3-9). Then, for each table T_k in RDB, for each row T_k^{i,:}, we create a hyperedge that connects the nodes associated with the attribute-value pairs, (Attr_k^j, T_{k,i,j}), contained by the row (Algorithm 1, Lines 10-16). For each hyperedge e corresponding to a row in the target table T_tg, the final embedding Z^L_e, where L is the last layer, represents the predicted class probability."

    Algorithm 1 iterates over every column j of every table T_k, including the target table's label column (is_fraud in Figure 1), so each training tuple hyperedge contains a node for the true label value. Equations 1-5 then make the final hyperedge embedding Z^L_e a learned function of exactly those node embeddings: F^0_e = MLP^0_E(sum_{v in e} Z^0_v), and Z^l_e is repeatedly aggregated from the same nodes. The paper then declares Z^L_e for target-table hyperedges to be the predicted class probability. Hence the label is an input feature, not merely supervision; the reported AUROC/RMSE gains in Tables 3 and 5 are explained by the model reading the answer from its own input. No exclusion of the target column is stated anywhere in Section 4.1 or the experimental setup.

full rationale

The central empirical claim, that rel-HNN significantly outperforms state-of-the-art methods on classification and regression, rests entirely on Tables 3 and 5. As written, the hypergraph construction in Algorithm 1 creates a node for every attribute-value pair in every column of every table, with no exception for the target label column. Consequently, each target-table hyperedge includes a node encoding the true label, and the final embedding that the paper calls the predicted class probability is a learned function of that label node. This is not a subtle modeling choice; it makes the prediction target part of the input representation by construction. The paper never states that the target column is omitted from the hypergraph or from the feature encodings, and the experimental section describes no special handling of it. Therefore the accuracy improvements in Tables 3 and 5 are explained by label leakage rather than by the proposed hypergraph representation. The split-parallel speedup experiments are separate empirical claims and are not themselves circular, but they do not rescue the central predictive-performance claim. Because the main result is forced by the input construction, the circularity score is 9.

Assumptions & free parameters 3 free parameters · 4 assumptions · 0 invented entities

The central claim rests on the hypergraph construction in Algorithm 1, which includes all attribute-value pairs, and on the AllSet-style message passing. The only free parameters explicitly stated are architectural dimensions, but the omission of the label column is the decisive premise. No new physical entities are introduced.

free parameters (3)
  • Number of layers L = 2
    Set to 2 for all rel-HNN variants; this depth is chosen by hand (Section 5.1).
  • Node and hyperedge embedding dimension = 2
    Fixed at 2 for all nodes and hyperedges in all experiments (Section 5.1).
  • Table embedding dimension = 8
    Used for rel-HNN-one-t and rel-HNN-av-t variants (Section 5.1).
assumptions (4)
  • ad hoc to paper All columns, including the target label column, are included as attribute-value nodes in hypergraph construction.
    Algorithm 1 loops over every column in every row without excluding the target; this is the load-bearing premise that causes label leakage.
  • domain assumption Attribute-value hypergraph captures relational semantics without using primary key-foreign key constraints.
    Section 4.1 motivates the representation as schema-agnostic, but no analysis shows that shared attribute-value nodes preserve the needed relational information.
  • domain assumption Two-phase node-to-hyperedge and hyperedge-to-node message passing is an effective inductive bias for tuple prediction.
    Section 4.2 adopts AllSet-style aggregation from prior hypergraph literature; its suitability for relational tuples is asserted, not derived.
  • domain assumption Train and test rows can be represented in the same hypergraph when test labels are absent.
    The experimental section does not describe how test hyperedges are constructed without labels, which is required for the reported evaluation to be valid.

how reviews work

0 comments
Cite this review

Pith. "Pith review of Rel-HNN: Split Parallel Hypergraph Neural Network for Learning on Relational Databases." pith.science (2026). https://pith.science/paper/V44XN6OX

@misc{pith2026250712562,
  author       = {Pith},
  title        = {Pith review of: Rel-HNN: Split Parallel Hypergraph Neural Network for Learning on Relational Databases},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/V44XN6OX}},
  note         = {Machine review of arXiv:2507.12562}
}
read the original abstract

Relational databases (RDBs) are ubiquitous in enterprise and real-world applications. Flattening the database poses challenges for deep learning models that rely on fixed-size input representations to capture relational semantics from the structured nature of relational data. Graph neural networks (GNNs) have been proposed to address this, but they often oversimplify relational structures by modeling all the tuples as monolithic nodes and ignoring intra-tuple associations. In this work, we propose a novel hypergraph-based framework, that we call rel-HNN, which models each unique attribute-value pair as a node and each tuple as a hyperedge, enabling the capture of fine-grained intra-tuple relationships. Our approach learns explicit multi-level representations across attribute-value, tuple, and table levels. To address the scalability challenges posed by large RDBs, we further introduce a split-parallel training algorithm that leverages multi-GPU execution for efficient hypergraph learning. Extensive experiments on real-world and benchmark datasets demonstrate that rel-HNN significantly outperforms existing methods in both classification and regression tasks. Moreover, our split-parallel training achieves substantial speedups -- up to 3.18x for learning on relational data and up to 2.94x for hypergraph learning -- compared to conventional single-GPU execution.

Figures

Figures reproduced from arXiv: 2507.12562 by the authors.

Figure 1
Figure 1. Schema Diagram of an example Relational Databse [PITH_FULL_IMAGE:figures/full_fig_p003_1.png] view at source ↗
Figure 2
Figure 2. An example hypergraph generation for a relational [PITH_FULL_IMAGE:figures/full_fig_p005_2.png] view at source ↗
Figure 3
Figure 3. HNN architecture for the hypergraph shown in Figure 2 [PITH_FULL_IMAGE:figures/full_fig_p006_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Split-Parallel learning of Hypergraph Neural Network (HNN) on two different GPUs. Blue and red shaded area [PITH_FULL_IMAGE:figures/full_fig_p007_4.png]
Figure 5
Figure 5. Figure 5: Training time per epoch (in milliseconds) across [PITH_FULL_IMAGE:figures/full_fig_p011_5.png]
Figure 6
Figure 6. Figure 6: Training time per epoch (in milliseconds) across [PITH_FULL_IMAGE:figures/full_fig_p012_6.png]
Figure 7
Figure 7. Figure 7: Training time per epoch (in milliseconds) across [PITH_FULL_IMAGE:figures/full_fig_p012_7.png]

Discussion (0). Sign in to comment.

Reference graph

Works this paper leans on

37 extracted references · 30 canonical work pages

  1. [1]

    Michael R Anderson, Dolan Antenucci, Victor Bittorf, Matthew Burgess, Michael J Cafarella, Arun Kumar, Feng Niu, Yongjoo Park, Christopher Ré, and Ce Zhang

    work page

  2. [2]

    James Atwood and Don Towsley. 2016. Diffusion-convolutional neural networks. Advances in neural information processing systems29 (2016)

    work page 2016

  3. [3]

    Alejandro Correa Bahnsen, Djamila Aouada, Aleksandar Stojanovic, and Björn Ottersten. 2016. Feature engineering strategies for credit card fraud detection. Expert Systems with Applications51 (2016), 134–142. 12

    work page 2016

  4. [4]

    Jinze Bai, Jialin Wang, Zhao Li, Donghui Ding, Ji Zhang, and Jun Gao. 2021. Atj-net: Auto-table-join network for automatic learning on relational databases. InProceedings of the web conference 2021. 1540–1551

    work page 2021

  5. [5]

    2022.Higher-order systems

    Federico Battiston and Giovanni Petri. 2022.Higher-order systems. Springer

    work page 2022

  6. [6]

    Eli Chien, Chao Pan, Jianhao Peng, and Olgica Milenkovic. 2022. You are AllSet: A Multiset Function Framework for Hypergraph Neural Networks. InInternational Conference on Learning Representations

    work page 2022

  7. [7]

    Paul Covington, Jay Adams, and Emre Sargin. 2016. Deep neural networks for youtube recommendations. InProceedings of the 10th ACM conference on recommender systems. 191–198

    2016

  8. [9]

    Milan Cvitkovic. 2020. Supervised learning on relational databases with graph neural networks.arXiv preprint arXiv:2002.02046(2020)

    arXiv 2020

Show all 37 references
  1. [10]

    Paul Expert and Giovanni Petri. 2022. Higher-order description of brain function. InHigher-Order Systems. Springer, 401–415

    2022

  2. [11]

    Yifan Feng, Haoxuan You, Zizhao Zhang, Rongrong Ji, and Yue Gao. 2019. Hy- pergraph neural networks. InProceedings of the AAAI conference on artificial intelligence, Vol. 33. 3558–3565

    2019

  3. [12]

    Swapnil Gandhi and Anand Padmanabha Iyer. 2021. P3: Distributed deep graph learning at scale. In15th{USENIX} Symposium on Operating Systems Design and Implementation ({OSDI}21). 551–568

    2021

  4. [13]

    Justin Gilmer, Samuel S Schoenholz, Patrick F Riley, Oriol Vinyals, and George E Dahl. 2017. Neural message passing for quantum chemistry. InInternational conference on machine learning. PMLR, 1263–1272

    2017

  5. [14]

    Rihan Hai, Christos Koutras, Andra Ionescu, Ziyu Li, Wenbo Sun, Jessie Van Schi- jndel, Yan Kang, and Asterios Katsifodimos. 2023. Amalur: Data integration meets machine learning. In2023 IEEE 39th International Conference on Data Engineering (ICDE). IEEE, 3729–3739

    2023

  6. [15]

    Will Hamilton, Zhitao Ying, and Jure Leskovec. 2017. Inductive representation learning on large graphs.Advances in neural information processing systems30 (2017)

    2017

  7. [16]

    Benjamin Hilprecht, Kristian Kersting, and Carsten Binnig. 2023. Spare: A single-pass neural model for relational databases.arXiv preprint arXiv:2310.13581 (2023)

    2023 arXiv

  8. [17]

    Zhichao Huang, Xutao Li, Yunming Ye, and Michael K Ng. 2020. MR-GCN: Multi-Relational Graph Convolutional Networks based on Generalized Tensor Product.. Innternational Joint Conference on Artificial Intelligence (IJCAI), Vol. 20. 1258–1264

    2020

  9. [18]

    Iacopo Iacopini, Giovanni Petri, Andrea Baronchelli, and Alain Barrat. 2022. Group interactions modulate critical mass dynamics in social convention.Com- munications Physics5, 1 (2022), 64

    2022

  10. [19]

    Ahmet Kara, Milos Nikolic, Dan Olteanu, and Haozhe Zhang. 2021. Machine learning over static and dynamic relational data. InProceedings of the 15th ACM International Conference on Distributed and Event-based Systems. 160–163

    2021

  11. [20]

    Sunwoo Kim, Soo Yong Lee, Yue Gao, Alessia Antelmi, Mirko Polato, and Kijung Shin. 2024. A survey on hypergraph neural networks: An in-depth and step-by- step guide. InProceedings of the 30th ACM SIGKDD Conference on Knowledge Discovery and Data Mining. 6534–6544

    2024

  12. [21]

    Thomas N Kipf and Max Welling. 2017. Semi-supervised classification with graph convolutional networks.International Conference on Learning Representations (ICLR)(2017)

    2017

  13. [22]

    Yujia Li, Daniel Tarlow, Marc Brockschmidt, and Richard Zemel. 2016. Gated graph sequence neural networks.International Conference on Learning Represen- tations (ICLR)(2016)

    2016

  14. [23]

    Manon A Morin, Anneliese J Morrison, Michael J Harms, and Rachel J Dut- ton. 2022. Higher-order interactions shape microbial interactions as microbial community complexity increases.Scientific Reports12, 1 (2022), 22640

    2022

  15. [24]

    Jan Motl and Oliver Schulte. 2024. The CTU Prague Relational Learning Reposi- tory. arXiv:1511.03086 [cs.LG] https://arxiv.org/abs/1511.03086

    2024 arXiv

  16. [25]

    Sandeep Polisetty, Juelin Liu, Jacob Falus, Yi Ren Fung, Seung Hwan Lim, Hui Guan, and Marco Serafini. 2025. GSplit: Scaling Graph Neural Network Training on Large Graphs via Probabilistic Splitting. InProceedings of the Conference on Machine Learning and Systems (MLSys)

    2025

  17. [26]

    Lenssen, Yiwen Yuan, Zecheng Zhang, Xinwei He, and Jure Leskovec

    Joshua Robinson, Rishabh Ranjan, Weihua Hu, Kexin Huang, Jiaqi Han, Alejandro Dobles, Matthias Fey, Jan E. Lenssen, Yiwen Yuan, Zecheng Zhang, Xinwei He, and Jure Leskovec. 2024. RelBench: A Benchmark for Deep Learning on Relational Databases. arXiv:2407.20060 [cs.LG] https://...

    2024 arXiv

  18. [27]

    Maximilian Schleich, Dan Olteanu, Mahmoud Abo-Khamis, Hung Q Ngo, and XuanLong Nguyen. 2019. Learning models over relational data: A brief tutorial. InScalable Uncertainty Management: 13th International Conference, SUM 2019, Compiègne, France, December 16–18, 2019, Proceedings...

    2019

  19. [28]

    Michael Schlichtkrull, Thomas N Kipf, Peter Bloem, Rianne Van Den Berg, Ivan Titov, and Max Welling. 2018. Modeling relational data with graph convolu- tional networks. InThe semantic web: 15th international conference, ESWC 2018, Heraklion, Crete, Greece, June 3–7, 2018, proc...

    2018

  20. [29]

    Yiwei Sun, Suhang Wang, Tsung Yu Hsieh, Xianfeng Tang, and Vasant Honavar

  21. [30]

    Nikolaos Tziavelis, Wolfgang Gatterbauer, and Mirek Riedewald. 2020. Optimal join algorithms meet top-k. InProceedings of the 2020 ACM SIGMOD International Conference on Management of Data. 2659–2665

    2020

  22. [31]

    Petar Velickovic, Guillem Cucurull, Arantxa Casanova, Adriana Romero, Pietro Lio, Yoshua Bengio, et al. 2018. Graph attention networks.International Confer- ence on Learning Representations (ICLR)(2018)

    2018

  23. [32]

    Xinchen Wan, Kaiqiang Xu, Xudong Liao, Yilun Jin, Kai Chen, and Xin Jin. 2023. Scalable and Efficient Full-Graph GNN Training for Large Graphs.Proc. ACM Manag. Data1, 2, Article 143 (June 2023), 23 pages

    2023

  24. [33]

    Minjie Wang, Da Zheng, Zihao Ye, Quan Gan, Mufei Li, Xiang Song, Jinjing Zhou, Chao Ma, Lingfan Yu, Yu Gai, et al. 2019. Deep graph library: A graph- centric, highly-performant package for graph neural networks.arXiv preprint arXiv:1909.01315(2019)

    2019 arXiv

  25. [34]

    Qiange Wang, Yanfeng Zhang, Hao Wang, Chaoyi Chen, Xiaodong Zhang, and Ge Yu. 2022. NeutronStar: Distributed GNN Training with Hybrid Dependency Management. InProceedings of the 2022 International Conference on Manage- ment of Data(Philadelphia, PA, USA)(SIGMOD ’22). Associati...

    2022

  26. [35]

    Keyulu Xu, Weihua Hu, Jure Leskovec, and Stefanie Jegelka. 2019. How powerful are graph neural networks?International Conference on Learning Representations (ICLR)(2019)

    2019

  27. [36]

    Naganand Yadati, Madhav Nimishakavi, Prateek Yadav, Vikram Nitin, Anand Louis, and Partha Talukdar. 2019. Hypergcn: A new method for training graph convolutional networks on hypergraphs.Advances in neural information pro- cessing systems32 (2019). 13

    2019

  28. [2013]

    Brainwash: A Data System for Feature Engineering.. InCidr

  29. [2019]

    In28th International Joint Conference on Artificial Intelligence, IJCAI 2019 (IJCAI)

    Megan: A generative adversarial network for multi-view network embed- ding. In28th International Joint Conference on Artificial Intelligence, IJCAI 2019 (IJCAI). International Joint Conferences on Artificial Intelligence, 3527–3533

    2019

Pith tools

Reviewed August 6, 2026 · model on record in the stance chip above.