Pith. sign in

REVIEW 3 major objections 8 minor 58 references

GraphHash: Graph Clustering Enables Parameter Efficiency in Recommender Systems

T0 review · 3 major / 8 minor · reviewed 2026-08-11 · deepseek-v4-flash

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

Pith's one-line read GraphHash shows that hashing users and items by modularity-based clusters, instead of by ID or frequency, shrinks embedding tables by over 75% and improves retrieval recall by 101.52% on average.

desk verdict Solid, practical empirical paper on graph-clustered embedding hashing; retrieval results are strong and believable, but the abstract overstates CTR and the theory is an unproven analogy. read the letter →

arxiv 2412.17245 v2 pith:WRV6SVXQ submitted 2024-12-23 cs.IR cs.SI

Xinyi Wu , Donald Loveland , Runjin Chen , Yozen Liu , Xin Chen , Leonardo Neves , Ali Jadbabaie , Clark Mingxuan Ju
show 2 more authors
Neil Shah Tong Zhao
This is my paper · ORCID
classification cs.IRcs.SI
keywords recommendersystemsembeddingtablecompressionhashingtrickmodularityclusteringbipartitegraphsmessagepassingcollaborativefilteringparameterefficiency
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

Deep recommender systems spend most of their memory on embedding tables that assign one vector per user and item. GraphHash is a preprocessing step that clusters the user-item interaction graph by modularity and then hashes every user and item to its cluster, so entities with similar interaction patterns share an embedding row. The paper claims this graph-structured hashing beats ID-based and frequency-based hashing baselines, improving average Recall@20 by 101.52% while using an embedding table more than 75% smaller on retrieval tasks. It also argues, through a random-walk interpretation, that modularity clustering is a coarser but much cheaper substitute for the smoothing that message-passing graph recommenders perform. If correct, graph structure could be spent once, before training, instead of in every forward pass.

What carries the argument

The central object is modularity on the bipartite user-item graph, $Q = \frac{1}{m} \sum_{C \in P} \sum_{u,i \in C} (A_{ui} - k_u d_i / m)$, where $A_{ui}=1$ for an interaction and $k_u, d_i$ are user and item degrees. Maximizing $Q$ partitions users and items so that edges are denser inside clusters than a degree-based null model predicts. The machinery then treats the optimal cluster label of each node as its hash bucket, relabeled to consecutive integers, computed once in preprocessing by a fast greedy modularity optimizer. In the random-walk reading, this is equivalent to fully smoothing embeddings within each cluster in one step, whereas message-passing smoothing is iterative and requires choosing the number of layers by hand.

What would settle it

Rewire the user-item graph to destroy community structure while keeping every user's and item's degree and frequency the same; if GraphHash's large recall advantage over frequency-based double hashing persists on this structureless graph, the benefit does not actually come from community structure, and if it vanishes, the effect is due to clustering real interaction communities.

Watch

Extended reading notes

Core claim

GraphHash replaces the standard hashing trick in recommender systems with bucket assignments derived from modularity-based clustering of the bipartite user-item interaction graph. The bucket assignment is the relabeled cluster of each node, so users or items in the same cluster share an embedding. The paper's central discovery is that structure-aware collisions are far less harmful than random or frequency-based collisions: with embedding tables reduced by more than 75%, GraphHash outperforms all hashing baselines on top-k retrieval across matrix factorization, NeuMF, LightGCN, and MF+DirectAU backbones, while its double-hashing variant, DoubleGraphHash, outperforms baselines on click-through-rate prediction. The paper further claims a theoretical grounding: modularity maximization has a random-walk interpretation, making GraphHash equivalent to fully smoothing embeddings within each cluster, a coarser but computationally cheaper relative of iterative message-passing.

Load-bearing premise

The load-bearing premise is that the clusters picked out by maximizing modularity are the same neighborhoods that message-passing would smooth over, a claim the paper supports with a random-walk analogy rather than with a proven approximation bound.

Editorial extensions

If this is right

  • At more than 75% embedding-table compression, structure-aware hashing can more than double retrieval recall over the strongest baseline, so memory and recommendation quality do not need to trade off as sharply as random hashing suggests.
  • GraphHash is plug-and-play: any backbone that consumes user and item embeddings can adopt it by changing only the ID-to-bucket map, including non-graph backbones such as matrix factorization and NeuMF.
  • Using the graph in preprocessing means structural information is paid for once, before training, rather than through extra message-passing layers at train and inference time.
  • The DoubleGraphHash variant, which pairs cluster buckets with a random hash function, is the top CTR performer, indicating that cluster-only buckets still need collision mitigation in high-precision tasks.
  • GraphHash distributes its benefit across heavy and light users, whereas frequency-based hashing mostly helps power users and skews toward popular items.

Reading between the lines

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

  • Inference: if the random-walk analogy is correct, the same cluster-then-share recipe could compress other high-cardinality categorical embeddings, such as ads or search features, wherever an interaction graph can be built.
  • Inference: the transductive preprocessing means users or items that appear only after clustering have no bucket; a production deployment would need a fallback hash for unseen IDs or incremental cluster updates.
  • Inference: because the theoretical link is qualitative rather than a proven bound, a direct test would compare cluster assignments against the smoothing neighborhoods of a trained LightGCN; strong disagreement would call for a revised explanation even if the empirical wins hold.
  • Inference: the modularity resolution parameter sweeps cluster size, effectively trading embedding-table size against smoothing range, which makes GraphHash a tunable memory-quality knob rather than a fixed compression ratio.
Share X Bluesky LinkedIn Reddit HN

Signed reviews

No signed human review yet.

Editorial analysis

A structured set of objections, weighed in public.

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

Referee Report

3 major / 8 minor

Summary. GraphHash is a preprocessing method for embedding-table compression in recommender systems. It clusters the user-item interaction bipartite graph with modularity maximization (Louvain) and uses the cluster IDs as hash buckets, so that users and items in the same cluster share an embedding row. A variant, DoubleGraphHash, combines GraphHash with a random double hash to reduce collisions. The paper reports large retrieval gains (on average a 101.52% recall improvement over the strongest baseline at more than 75% parameter reduction), smaller CTR gains that are mainly due to DoubleGraphHash, and a suite of ablations over training objectives, GNN depth, clustering resolution, clustering objectives, sparsity levels, and additional backbones and datasets.

Significance. The empirical evaluation is a genuine strength: it spans six public datasets, multiple backbones (MF, NeuMF, LightGCN, iALS, WideDeep, DLRM, DCNv2, DeepFM), and uses matched or smaller embedding-table sizes for GraphHash, with code released. The retrieval results are large, consistent, and reproducible in structure; the ablations (resolution sweep, spectral co-clustering comparison, sparsity analysis) are informative. If the retrieval effects replicate, GraphHash offers a simple industrial preprocessing alternative to hashing tricks. The main weaknesses are presentational: the abstract attributes CTR gains to GraphHash when they come from DoubleGraphHash, and the claimed theoretical connection to message-passing is not established. Neither issue invalidates the retrieval results, but both need correction before publication.

major comments (3)
  1. [Section 3.4; Abstract; Contributions] The manuscript claims to 'demonstrate that the modularity objective has a theoretical connection to message-passing' (Abstract and Contribution list). Section 3.4 provides an algebraic rewriting of modularity with a random-walk interpretation and then states that GraphHash is a coarser but more efficient smoothing operation, but it contains no theorem, equivalence, or bound relating the modularity-optimal partition to message-passing neighborhoods, nor any error bound for fully tying embeddings within clusters relative to iterative message-passing. The smoothness evidence in Table 3 (within-cluster variance of full-model embeddings) is a post-hoc correlation check and does not validate this proxy relationship. Since the theoretical foundation is advertised as a core contribution, either supply a formal statement or rephrase the claims as a random-walk interpretation and remove 'demonstrate' and 'theoretical connection' from the abstract and contributions.
  2. [Abstract; Section 5.2.2; Table 2] The abstract states that GraphHash 'substantially outperforms diverse hashing baselines on both retrieval and click-through-rate prediction tasks,' but Table 2 shows that plain GraphHash (Eq. 1) is often worse than double or frequency hashing on CTR metrics; for example, on MovieLens-20M with DLRM, GraphHash achieves LogLoss 0.347 vs. 0.341 for double and AUC 0.873 vs. 0.879 for double, and on MovieLens-1M with WideDeep, GraphHash AUC is 0.841 vs. 0.860 for double. The CTR gains are achieved by DoubleGraphHash (Eq. 2), not by GraphHash. The contributions bullet reporting 'a 2.9% improvement in LogLoss and a 0.2% gain in AUC' should explicitly attribute these numbers to DoubleGraphHash, and the abstract should qualify its CTR claim accordingly.
  3. [Appendix B; Abstract; Introduction] All experiments use a transductive setting: Appendix B preprocesses each dataset so that every validation/test user and item appears in the training graph. This means GraphHash cannot assign buckets to out-of-vocabulary entities at inference, unlike ordinary hash functions, and it limits the 'plug-and-play graph-based alternative to traditional ID hashing' claim in the abstract and introduction. Please state this limitation prominently in the main text (not only in a sentence in Appendix B) and qualify the plug-and-play claim, or demonstrate a handling strategy for OOV entities.
minor comments (8)
  1. [Algorithm 1] Algorithm 1: the line 'item_vocab = np.unique(user_clusters)' should read 'item_vocab = np.unique(item_clusters)'; as printed, the item vocabulary is built from the user clusters.
  2. [Section 6.2] Section 6.2, paragraph 2: 'can be sorely attributed' should be 'can be solely attributed'.
  3. [Section 3.3, Eq. (2)] Section 3.3, Eq. (2): it is not specified how the pair (H(x), GraphHash(x)) is mapped to a row index in the embedding table; please state explicitly (e.g., a compound key H(x) * |P*| + GraphHash(x) or concatenation).
  4. [Appendix B] Appendix B: the transductive preprocessing (removing OOV IDs) should be described in Section 5.1's setup as a limitation, not only in the appendix and conclusion.
  5. [Section 3.2] Section 3.2: 'assignements' should be 'assignments'; also, the summation notation 'sum_{u,i in C}' could be clarified as a double sum over user-item pairs within a cluster.
  6. [Proposition 3.1] Proposition 3.1: as stated, the Louvain algorithm is not deterministic in general; the proof relies on a particular implementation's fixed node ordering and shuffling. Please restate the proposition conditionally on a fixed input order and random seed.
  7. [Table 3] Table 3: the last value '42.2439' contains an apparent stray digit, and the table would benefit from uniform decimal formatting.
  8. [Section 5.1.2] Section 5.1.2: the LSH baseline is omitted for Frappe in Table 2; please explain why (e.g., no side features available) in the setup.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity: GraphHash's clustering-based hashing is evaluated on held-out interactions, and its modularity-message-passing link is a heuristic analogy, not a derived equality.

full rationale

GraphHash's pipeline is self-contained against external benchmarks: the bipartite modularity objective is taken from Barber [4], Louvain is an external algorithm [5], and the only method-specific hyperparameter (the Louvain resolution) is used to control the number of embedding-table buckets rather than to fit the reported metrics. Cluster assignments are computed from training edges, while retrieval and CTR metrics are evaluated on held-out test interactions, so no fitted parameter is renamed as a prediction. The closest candidate for circularity is Section 3.4, where the paper argues from the random-walk interpretation of modularity that GraphHash 'can be seen as a coarser but more efficient way to perform smoothing over the graph, similar to iterative message-passing.' This is an informal analogy rather than a proven equivalence: the paper offers no theorem identifying modularity-optimal clusters with message-passing neighborhoods and no approximation bound, and the observation that entities in one bucket share an embedding is true by construction. That makes the theoretical framing heuristic and potentially undersupported as a foundation, but it is not circular, because modularity is not defined in terms of message-passing and the empirical gains do not reduce to the definition. The self-citations present in the paper, such as [30] and [45], are used for data splits, related work, or a side observation about DirectAU loss, and they are not load-bearing for the central claim. Therefore no circular step can be exhibited, and a score of 0 is appropriate.

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

The method's only tunable input is the Louvain resolution, which sets the embedding table size. The theoretical argument relies on known random-walk properties of modularity and on the smoothing benefit of message-passing, both taken from prior literature. The evaluation assumes a transductive graph. No new entities are introduced.

free parameters (1)
  • Louvain resolution = varies by dataset and task (e.g., 50-400 for retrieval; 3-20 for CTR)
    Controls the number and size of communities, and therefore the number of rows in the reduced embedding table; the paper tunes it to match the target parameter budget and studies sensitivity in Table 4.
assumptions (4)
  • standard math Modularity maximization has a random-walk interpretation: an optimal partition maximizes the probability that a random walker stays in its starting community relative to chance.
    Invoked in Section 3.4 to connect clustering to message-passing. Drawn from Barber 2007 and Lambiotte et al. 2008.
  • domain assumption Message-passing smoothing, as in LightGCN, improves collaborative filtering performance by aggregating neighbor embeddings.
    Theoretical motivation in Sections 3.4 and 6.3; treated as established in prior literature.
  • domain assumption Louvain's greedy heuristic finds good modularity partitions efficiently on large bipartite graphs.
    The method relies on Louvain to produce the bucket assignments; no optimality guarantee is used.
  • ad hoc to paper The user-item interaction graph is available at preprocessing time and covers all evaluation entities (transductive setting).
    Appendix B removes all out-of-vocabulary IDs from validation and test sets, so the paper does not evaluate cold-start or unseen entities.

how reviews work

0 comments
Cite this review

Pith. "Pith review of GraphHash: Graph Clustering Enables Parameter Efficiency in Recommender Systems." pith.science (2026). https://pith.science/paper/WRV6SVXQ

@misc{pith2026241217245,
  author       = {Pith},
  title        = {Pith review of: GraphHash: Graph Clustering Enables Parameter Efficiency in Recommender Systems},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/WRV6SVXQ}},
  note         = {Machine review of arXiv:2412.17245}
}
read the original abstract

Deep recommender systems rely heavily on large embedding tables to handle high-cardinality categorical features such as user/item identifiers, and face significant memory constraints at scale. To tackle this challenge, hashing techniques are often employed to map multiple entities to the same embedding and thus reduce the size of the embedding tables. Concurrently, graph-based collaborative signals have emerged as powerful tools in recommender systems, yet their potential for optimizing embedding table reduction remains unexplored. This paper introduces GraphHash, the first graph-based approach that leverages modularity-based bipartite graph clustering on user-item interaction graphs to reduce embedding table sizes. We demonstrate that the modularity objective has a theoretical connection to message-passing, which provides a foundation for our method. By employing fast clustering algorithms, GraphHash serves as a computationally efficient proxy for message-passing during preprocessing and a plug-and-play graph-based alternative to traditional ID hashing. Extensive experiments show that GraphHash substantially outperforms diverse hashing baselines on both retrieval and click-through-rate prediction tasks. In particular, GraphHash achieves on average a 101.52% improvement in recall when reducing the embedding table size by more than 75%, highlighting the value of graph-based collaborative information for model reduction. Our code is available at https://github.com/snap-research/GraphHash.

Figures

Figures reproduced from arXiv: 2412.17245 by the authors.

Figure 1
Figure 1. Overview of GraphHash. By employing fast graph clustering algorithms, GraphHash serves as a computationally efficient proxy for message-passing during preprocessing and a plug-and-play graph-based alternative to traditional ID hashing, working seamlessly with any architectural backbone that utilizes embedding tables. delves into the detailed formulation of GraphHash and its vari￾ant, DoubleGraphHash. Finally, Sectio… view at source ↗
Figure 2
Figure 2. Performance breakdown of the retrieval task by test user frequency in the training data. Frequency information tends to benefit [PITH_FULL_IMAGE:figures/full_fig_p006_2.png] view at source ↗
Figure 3
Figure 3. Performance breakdown of the CTR task by user frequency in training data. All methods tend to perform better for clicks generated [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗
Figures from the paper (4 more)
Figure 4
Figure 4. Figure 4: Impact of the uniformity term 𝛾 in DirectAU on model performance. While the full model and GraphHash are robust to changes in 𝛾, double frequency hashing shows a sweet spot, sug￾gesting GraphHash enhances robustness to 𝛾 in hashing methods. the strength of the uniformi…
Figure 5
Figure 5. Figure 5: The impact of LightGCN’s depth on the performance [PITH_FULL_IMAGE:figures/full_fig_p008_5.png]
Figure 6
Figure 6. Figure 6: The impact of the strength of uniformity term [PITH_FULL_IMAGE:figures/full_fig_p011_6.png]
Figure 7
Figure 7. Figure 7: The impact of LightGCN’s depth on the performance of [PITH_FULL_IMAGE:figures/full_fig_p011_7.png]

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

58 extracted references · 48 canonical work pages

  1. [1]

    Aggarwal, C. C. Recommender Systems. Springer, 2016

    work page 2016

  2. [2]

    C., and Lang, K

    Andersen, R., Graham, F. C., and Lang, K. J. Local graph partitioning using pagerank vectors. 2006 47th Annual IEEE Symposium on Foundations of Computer Science (FOCS’06) (2006), 475–486

    work page 2006

  3. [3]

    Frappe: Under- standing the usage and perception of mobile app recommendations in-the-wild

    Baltrunas, L., Church, K., Karatzoglou, A., and Oliver, N. Frappe: Under- standing the usage and perception of mobile app recommendations in-the-wild. ArXiv abs/1505.03014 (2015)

    arXiv 2015

  4. [4]

    Barber, M. J. Modularity and community detection in bipartite networks. Physi- cal Review E 76 , 6 (2007), 066102

    work page 2007

  5. [5]

    D., Guillaume, J.-L., Lambiotte, R., and Lefebvre, E.Fast unfolding of communities in large networks

    Blondel, V. D., Guillaume, J.-L., Lambiotte, R., and Lefebvre, E.Fast unfolding of communities in large networks. Journal of Statistical Mechanics: Theory and Experiment 2008 (2008), P10008

    work page 2008

  6. [6]

    Recommender systems survey

    Bobadilla, J., Ortega, F., Hernando, A., and Gutiérrez, A. Recommender systems survey. Knowl. Based Syst. (2013)

    work page 2013

  7. [7]

    Scikit-network: Graph analysis in python

    Bonald, T., de Lara, N., Lutz, Q., and Charpentier, B. Scikit-network: Graph analysis in python. Journal of Machine Learning Research 21 , 185 (2020), 1–6

    work page 2020

  8. [8]

    ArXiv physics/0608255 (2006)

    Brandes, U., Delling, D., Gaertler, M., Goerke, R., Hoefer, M., Nikoloski, Z., and W agner, D.Maximizing modularity is hard. ArXiv physics/0608255 (2006)

    arXiv 2006

Show all 58 references
  1. [9]

    B., Anderson, G., Corrado, G

    Cheng, H.-T., Koc, L., Harmsen, J., Shaked, T., Chandra, T., Aradhye, H. B., Anderson, G., Corrado, G. S., Chai, W., Ispir, M., Anil, R., Haqe, Z., Hong, L., Jain, V., Liu, X., and Shah, H. Wide & deep learning for recommender systems. Proceedings of the 1st Workshop on Deep L...

    2016

  2. [10]

    Adaptive factorization network: Learning adaptive-order feature interactions

    Cheng, W., Shen, Y., and Huang, L. Adaptive factorization network: Learning adaptive-order feature interactions. In AAAI (2020)

    2020

  3. [11]

    A., and Leskovec, J

    Cho, E., Myers, S. A., and Leskovec, J. Friendship and mobility: user movement in location-based social networks. In Knowledge Discovery and Data Mining (2011)

    2011

  4. [12]

    H., and Cheng, D

    Coleman, B., Kang, W.-C., Fahrbach, M., W ang, R., Hong, L., Chi, E. H., and Cheng, D. Z. Unified embedding: Battle-tested feature representations for web- scale ml systems. In NeurIPS (2023)

    2023

  5. [13]

    N., and Barahona, M

    Delvenne, J.-C., Yaliraki, S. N., and Barahona, M. Stability of graph com- munities across time scales. Proceedings of the National Academy of Sciences (2008)

    2008

  6. [14]

    Dhillon, I. S. Co-clustering documents and words using bipartite spectral graph partitioning. In KDD (2001)

    2001

  7. [15]

    From local to global: A graph rag approach to query-focused summarization

    Edge, D., Trinh, H., Cheng, N., Bradley, J., Chao, A., Mody, A., Truitt, S., and Larson, J. From local to global: A graph rag approach to query-focused summarization. ArXiv abs/2404.16130 (2024). arXiv version Xinyi Wu et al

    2024 arXiv

  8. [16]

    E., Weichert, F., and Leskovec, J

    Fey, M., Lenssen, J. E., Weichert, F., and Leskovec, J. Gnnautoscale: Scalable and expressive graph neural networks via historical embeddings. In International conference on machine learning (2021), PMLR, pp. 3294–3304

    2021

  9. [17]

    A survey of graph neural networks for recommender systems: Challenges, methods, and directions

    Gao, C., Zheng, Y., Li, N., Li, Y., Qin, Y., Piao, J., Quan, Y., Chang, J., Jin, D., He, X., and Li, Y. A survey of graph neural networks for recommender systems: Challenges, methods, and directions. ACM Transactions on Recommender Systems (2021)

    2021

  10. [18]

    Learning image and user features for recommendation in social networks

    Geng, X., Zhang, H., Bian, J., and Chua, T.-S. Learning image and user features for recommendation in social networks. In ICCV (2015)

    2015

  11. [19]

    Learning to collide: Recommendation system model compression with learned hash functions

    Ghaemmaghami, B., Ozdal, M., Komuravelli, R., Korchev, D., Mudigere, D., Nair, K., and Naumov, M. Learning to collide: Recommendation system model compression with learned hash functions. ArXiv abs/2203.15837 (2022)

    2022 arXiv

  12. [20]

    S., Riley, P

    Gilmer, J., Schoenholz, S. S., Riley, P. F., Vinyals, O., and Dahl, G. E. Neural message passing for quantum chemistry. In ICML (2017)

    2017

  13. [21]

    Deepfm: A factorization-machine based neural network for ctr prediction

    Guo, H., Tang, R., Ye, Y., Li, Z., and He, X. Deepfm: A factorization-machine based neural network for ctr prediction. ArXiv abs/1703.04247 (2017)

    2017 arXiv

  14. [22]

    V., Shah, N., and Zhao, T

    Guo, Z., Shiao, W., Zhang, S., Liu, Y., Chawla, N. V., Shah, N., and Zhao, T. Linkless link prediction via relational distillation. In International Conference on Machine Learning (2023), PMLR, pp. 12012–12033

    2023

  15. [23]

    M., Cot- tel, B., Hazelwood, K

    Gupta, U., Wang, X., Naumov, M., Wu, C.-J., Reagen, B., Brooks, D. M., Cot- tel, B., Hazelwood, K. M., Jia, B., Lee, H.-H. S., Malevich, A., Mudigere, D., Smelyanskiy, M., Xiong, L., and Zhang, X. The architectural implications of facebook’s dnn-based personalized recommendati...

    2020

  16. [24]

    Mlpinit: Embarrassingly simple gnn training acceleration with mlp initialization

    Han, X., Zhao, T., Liu, Y., Hu, X., and Shah, N. Mlpinit: Embarrassingly simple gnn training acceleration with mlp initialization. arXiv preprint arXiv:2210.00102 (2022)

    2022 arXiv

  17. [25]

    M., Konstan, J

    Harper, F. M., Konstan, J. A., and A., J. The movielens datasets: History and context. ACM Trans. Interact. Intell. Syst. 5 (2016), 19:1–19:19

    2016

  18. [26]

    In WWW (2016)

    He, R., and McAuley, J.Ups and downs: Modeling the visual evolution of fashion trends with one-class collaborative filtering. In WWW (2016)

    2016

  19. [27]

    In Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval (2020)

    He, X., Deng, K., W ang, X., Li, Y., Zhang, Y., and W ang, M.Lightgcn: Simplifying and powering graph convolution network for recommendation. In Proceedings of the 43rd International ACM SIGIR Conference on Research and Development in Information Retrieval (2020)

    2020

  20. [28]

    Neural collaborative filtering, 2017

    He, X., Liao, L., Zhang, H., Nie, L., Hu, X., and Chua, T.-S. Neural collaborative filtering, 2017

    2017

  21. [29]

    Collaborative filtering for implicit feedback datasets

    Hu, Y., Koren, Y., and Volinsky, C. Collaborative filtering for implicit feedback datasets. In ICDM (2008)

    2008

  22. [30]

    How does message passing improve collaborative filtering? In NeurIPS (2024)

    Ju, M., Shiao, W., Guo, Z., Ye, Y., Liu, Y., Shah, N., and Zhao, T. How does message passing improve collaborative filtering? In NeurIPS (2024)

    2024

  23. [31]

    Z., Y ao, T., Yi, X., Chen, T.-L., Hong, L., and Chi, E

    Kang, W.-C., Cheng, D. Z., Y ao, T., Yi, X., Chen, T.-L., Hong, L., and Chi, E. H. Learning to embed categorical features without embedding tables for recom- mendation. In Proceedings of the 27th ACM SIGKDD Conference on Knowledge Discovery & Data Mining (2020)

    2020

  24. [32]

    P., and Ba, J

    Kingma, D. P., and Ba, J. Adam: A method for stochastic optimization. CoRR abs/1412.6980 (2014)

    2014 arXiv

  25. [33]

    N., and Welling, M

    Kipf, T. N., and Welling, M. Semi-supervised classification with graph convo- lutional networks. In ICLR (2017)

    2017

  26. [34]

    M., and Volinsky, C

    Koren, Y., Bell, R. M., and Volinsky, C. Matrix factorization techniques for recommender systems. Computer 42 (2009)

    2009

  27. [35]

    Laplacian dynamics and multiscale modular structure in networks

    Lambiotte, R., Delvenne, J.-C., and Barahona, M. Laplacian dynamics and multiscale modular structure in networks. arXiv preprint arXiv:0812.1770 (2008)

    2008 arXiv

  28. [36]

    In SIGIR (2024)

    Liang, X., Chen, T., zhen Cui, L., W ang, Y., W ang, M., and Yin, H.Lightweight embeddings for graph collaborative filtering. In SIGIR (2024)

    2024

  29. [37]

    ArXiv (2022)

    Liu, Z.-P., Zou, L., Zou, X., W ang, C., Zhang, B., Tang, D., Zhu, B., Zhu, Y., Wu, P., W ang, K., and Cheng, Y.Monolith: Real time recommendation system with collisionless embedding table. ArXiv (2022)

    2022

  30. [38]

    Deep learning training in facebook data centers: Design of scale-up and scale-out systems

    Naumov, M., Kim, J., Mudigere, D., Sridharan, S., Wang, X., Zhao, W., Yil- maz, S., Kim, C., Yuen, H., Ozdal, M., Nair, K., Gao, I., Su, B.-Y., Y ang, J., and Smelyanskiy, M. Deep learning training in facebook data centers: Design of scale-up and scale-out systems. ArXiv abs/2...

    2020 arXiv

  31. [39]

    M., Huang, J., Sundaraman, N., Park, J., Wang, X., Gupta, U., Wu, C., Azzolini, A

    Naumov, M., Mudigere, D., Shi, H. M., Huang, J., Sundaraman, N., Park, J., Wang, X., Gupta, U., Wu, C., Azzolini, A. G., Dzhulgakov, D., Mallevich, A., Cherniavskii, I., Lu, Y., Krishnamoorthi, R., Yu, A., Kondratenko, V., Pereira, S., Chen, X., Chen, W., Rao, V., Jia, B., Xio...

    2019 arXiv

  32. [40]

    Newman, M. E. J. Modularity and community structure in networks. Proceedings of the National Academy of Sciences of the United States of America 103 23 (2006), 8577–82

    2006

  33. [41]

    I., and Weiss, Y

    Ng, A., Jordan, M. I., and Weiss, Y. On spectral clustering: Analysis and an algorithm. In NeurIPS (2001)

    2001

  34. [42]

    Graph neural networks exponentially lose expressive power for node classification

    Oono, K., and Suzuki, T. Graph neural networks exponentially lose expressive power for node classification. In ICLR (2020)

    2020

  35. [43]

    Bpr: Bayesian personalized ranking from implicit feedback

    Rendle, S., Freudenthaler, C., Gantner, Z., and Schmidt-Thieme, L. Bpr: Bayesian personalized ranking from implicit feedback. In UAI (2009)

    2009

  36. [44]

    T.Maps of random walks on complex networks reveal community structure

    Rosvall, M., and Bergstrom, C. T.Maps of random walks on complex networks reveal community structure. Proceedings of the National Academy of Sciences (2007)

    2007

  37. [45]

    E., Zhao, T., Shah, N., and Liu, Y

    Shiao, W., Ju, M., Guo, Z., Chen, X., Papalexakis, E. E., Zhao, T., Shah, N., and Liu, Y. Improving out-of-vocabulary handling in recommendation systems. ArXiv abs/2403.18280 (2024)

    2024 arXiv

  38. [46]

    Graph attention networks

    Veličković, P., Cucurull, G., Casanova, A., Romero, A., Liò, P., and Bengio, Y. Graph attention networks. In ICLR (2018)

    2018

  39. [47]

    Towards representation alignment and uniformity in collaborative filtering

    Wang, C., Yu, Y., Ma, W., Zhang, M., Chen, C., Liu, Y., and Ma, S. Towards representation alignment and uniformity in collaborative filtering. In Proceedings of the 28th ACM SIGKDD Conference on Knowledge Discovery and Data Mining (2022)

    2022

  40. [48]

    Z., Jain, S., Lin, D., Hong, L., and Chi, E

    W ang, R., Shivanna, R., Cheng, D. Z., Jain, S., Lin, D., Hong, L., and Chi, E. H. Dcn v2: Improved deep & cross network and practical lessons for web-scale learning to rank systems. In Proceedings of the Web Conference (2021)

    2021

  41. [49]

    In Proceedings of the 42nd International ACM SIGIR Conference on Research and Development in Information Retrieval (2019)

    W ang, X., He, X., W ang, M., Feng, F., and Chua, T.-S.Neural graph collaborative filtering. In Proceedings of the 42nd International ACM SIGIR Conference on Research and Development in Information Retrieval (2019)

    2019

  42. [50]

    Q., Dasgupta, A., Attenberg, J., Langford, J., and Smola, A

    Weinberger, K. Q., Dasgupta, A., Attenberg, J., Langford, J., and Smola, A. Feature hashing for large scale multitask learning. In International Conference on Machine Learning (2009)

    2009

  43. [51]

    Demystifying oversmoothing in attention-based graph neural networks

    Wu, X., Ajorlou, A., Wu, Z., and Jadbabaie, A. Demystifying oversmoothing in attention-based graph neural networks. In NeurIPS (2023)

    2023

  44. [52]

    In ICLR (2023)

    Wu, X., Chen, Z., W ang, W., and Jadbabaie, A.A non-asymptotic analysis of oversmoothing in graph neural networks. In ICLR (2023)

    2023

  45. [53]

    In 2022 IEEE International Conference on Data Mining (ICDM) (2022), pp

    Wu, X., Sarker, A., and Jadbabaie, A.Link partitioning on simplicial complexes using higher-order laplacians. In 2022 IEEE International Conference on Data Mining (ICDM) (2022), pp. 1239–1244

    2022

  46. [54]

    How powerful are graph neural networks? In ICLR (2019)

    Xu, K., Hu, W., Leskovec, J., and Jegelka, S. How powerful are graph neural networks? In ICLR (2019)

    2019

  47. [55]

    I., Tejani, A., Gupta, A., Myana, P

    Zhang, C., Liu, Y., Xie, Y., Ktena, S. I., Tejani, A., Gupta, A., Myana, P. K., Dilipkumar, D., Paul, S., Ihara, I., Upadhyaya, P., Huszár, F., and Shi, W.Model size reduction using frequency based double hashing for recommender systems. In Proceedings of the 14th ACM Conferen...

    2020

  48. [56]

    Graph-less neural networks: Teach- ing old mlps new tricks via distillation

    Zhang, S., Liu, Y., Sun, Y., and Shah, N. Graph-less neural networks: Teach- ing old mlps new tricks via distillation. International Conference on Learning Representations (2022)

    2022

  49. [57]

    Deep learning based recommender system: A survey and new perspectives

    Zhang, S., Yao, L., Sun, A., and Tay, Y. Deep learning based recommender system: A survey and new perspectives. ACM Computing Surveys (2019)

    2019

  50. [58]

    Learning from graphs beyond message passing neural networks

    Zhao, T., Shah, N., and Ghazizadeh, E. Learning from graphs beyond message passing neural networks. In Tiny Papers @ ICLR (2024). A Proof of Proposition 3.1 Proof. Note that given a graph, the procedures in the Louvain algorithm [5] iterate through the nodes in the order by th...

    2024

Pith tools

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