DCN^2: Interplay of Implicit Collision Weights and Explicit Cross Layers for Large-Scale Recommendation

Assaf Klein; Bla\v{z} Mramor; Bla\v{z} \v{S}krlj; Grega Ga\v{s}per\v{s}i\v{c}; Jasna Urban\v{c}i\v{c}; Martin Jakomin; Natalia Silberstein; Ophir Friedler; Yonatan Karni; Yulia Stolin

REVIEW 5 major objections 5 minor 1 cited by

DCN^2: Interplay of Implicit Collision Weights and Explicit Cross Layers for Large-Scale Recommendation

T0 review · 5 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 The paper claims that three targeted changes to DCNv2 — learnable per-lookup collision weights, a dense 'onlydense' cross layer, and an explicit FFM-like pairwise-similarity logit — deliver consistent offline gains on four public CTR…

desk verdict A real industrial DCNv2 extension with a genuinely new collision-weighting trick, but the evidence is weaker than the abstract claims: no matched-capacity baseline, an iPinYou loss that contradicts 'superior on four benchmarks,' and a confounded AutoML case study. read the letter →

arxiv 2506.21624 v1 pith:5DDRIWTX submitted 2025-06-24 cs.IR cs.LG

Blaž Škrlj , Yonatan Karni , Grega Gašperšič , Blaž Mramor , Yulia Stolin , Martin Jakomin , Jasna Urbančič , Yuval Dishi

show 3 more authors

Natalia Silberstein Ophir Friedler Assaf Klein

This is my paper

classification cs.IRcs.LG

keywords Deep&CrossNetworkDCNv2factorizationmachinesfeaturecollisionshashingtrickclick-throughratepredictionlarge-scalerecommendersystemssimilaritylayer

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 tries to establish that the widely used DCNv2 recommender architecture can be improved without leaving its efficiency regime. Its proposed successor, $DCN^{2}$, makes three targeted changes: each embedding lookup gets a learnable scalar weight that down-weights hashed collisions; the low-rank Cross layer is replaced by a dense 'onlydense' layer that crosses inputs in full dimension; and a lightweight SimLayer adds an explicit FFM-like pairwise-similarity logit. On four public CTR benchmarks $DCN^{2}$ matches or beats DCNv2 in average AUC, and in a live system it is reported to outperform the DCNv2-based model, with revenue gains of roughly 3% under A/B tests while sustaining over 0.5 billion predictions per second. A sympathetic reader would care because the changes are drop-in components with modest compute overhead, aimed at a production baseline many real systems already run.

What carries the argument

Three mechanisms carry the argument. (1) Collision-weighted lookups: an embedding table of width $d$ gains a $d+1$-th column of learned scalars initialized to 1; each row is scaled by its scalar, giving the network a differentiable way to suppress embeddings corrupted by hashing collisions. (2) The onlydense Cross layer: a full $d \times d$ weight matrix with ReLU, followed by a scaled Hadamard product with the input $x_t \odot x \cdot \varphi$, replacing the low-rank $W_0$/$W_1$ projection and the residual addition of DCNv2's Cross layer. (3) SimLayer: an explicit pairwise dot-product term, weighted per embedding-index pair and activated, added as an extra logit to the final DCN prediction. The paper's complexity claims are that the onlydense layer is $O(d^2)$, the same as the basic Cross layer, while collision weights cost $O(|X|)$ extra multiplications per lookup.

What would settle it

Train DCNv2 with a wider low-rank projection to match the parameter count, memory, and FLOPs of the onlydense layer, and run the same single-pass protocol with the same hyperparameter budget; then remove the collision weights and SimLayer one at a time. If the AUC differences on Avazu and Criteo shrink to noise and the reported online RPM lift disappears, the proposed mechanisms are not what carries the gain.

Watch

Extended reading notes

Core claim

On its own terms, the paper's central discovery is that the three components are complementary and that their combination generalizes at scale. Collision-weighted lookups attach an extra differentiable scalar to each row of the embedding table, starting at 1.0, so the network can learn to silence embeddings that suffer from hash collisions instead of relying on external hashing schemes. The onlydense layer removes the projection bottleneck of DCNv2's low-rank Cross layer, performing explicit crosses in the intrinsic dense space via a scaled Hadamard product without the anchor-residual sum. The SimLayer adds a single dot-product-based pairwise-similarity logit that emulates field-aware factorization machines at a fraction of their cost. Together these components yield higher average AUC on Avazu, Criteo, and KDD2012, a quasilinear relationship between hash-space size and performance that favors $DCN^{2}$ as collisions increase, and, in production, an aggregate online lift (e.g. +3.2% RPM for CTR use cases) at more than 0.5 billion predictions per second.

Load-bearing premise

The load-bearing premise is that DCNv2's low-rank Cross projection actually loses information and that DCNv2 genuinely omits pairwise interactions the SimLayer adds; the paper asserts both arguments rather than proving them, and its comparisons do not isolate each new component against a DCNv2 variant of matched capacity.

Editorial extensions

If this is right

DCN^2 can be deployed as a drop-in replacement for DCNv2 in existing systems: the paper reports migrating a live win-probability model, removing all explicit feature combinations, and still getting an offline RIG lift of 0.01552.
Because collision weights are downstream-agnostic, any lookup-based embedding model could adopt them to soften the impact of hashing collisions without changing hash functions.
The hash-space scaling results imply DCN^2 is better suited than DCNv2 to small hash tables, which matters for memory-constrained deployment.
At production scale the architecture sustains more than 0.5 billion predictions per second after service-layer optimizations, with p99 latency reduced by 18% through thread pinning and spin-wait removal.
The combination of dense crossing and explicit pairwise similarity means DCN^2 models can rely on fewer hand-crafted feature interactions.

Reading between the lines

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

If the onlydense layer's advantage comes mainly from added capacity rather than from avoiding projection information loss, then a DCNv2 variant with a wider low-rank projection at matched parameter count should close most of the gap; the paper's ablations do not yet settle this.
The collision-weight mechanism is presented as a solution to hash collisions, but its heavy-tailed learned distribution suggests it may also act as a feature-importance or freshness signal; that interpretation is untested.
The reported online gains aggregate several A/B tests across use cases; per-use-case variance is not shown, so the headline lift may not replicate uniformly for every client or traffic slice.
A natural extension is to apply the same collision-weight idea to categorical features in non-recommendation tabular models, where hashed one-hot encodings also suffer collisions.

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.

Desk Editor's Note

read the letter

I read the DCN^2 paper. The core idea I'd take away is the collision-weight column: a per-lookup scalar that modulates the embedding, initialized at 1.0. That's simple, cheap, and the hash-space scaling experiment (Figure 3) is a decent controlled demonstration that it helps when collisions get worse. The SimLayer is a straightforward FFM-like additive term, and the ablation (DCN^2 -simk) shows it contributes on three of four datasets. The deployment numbers (0.5 billion pps, A/B lifts) are credible as an industrial claim, though underexplained.

The soft spots are the usual ones for this genre, but they matter. The biggest is that every offline comparison is against the low-rank DCNv2 Cross layer, which is O(d·p). The onlydense replacement is O(d^2). No baseline matches capacity, parameter count, or FLOPs, so the small AUC gains (~0.002) could just be extra capacity. That undercuts the claim that the specific mechanisms drive the gains. A matched-capacity DCNv2 variant (wider projection, same FLOPs) is needed to rule out the trivial explanation.

The abstract says "superior performance on four publicly available benchmark data sets," but Table 1 shows DCN^2 loses on iPinYou (0.7561 vs 0.7659). That is a direct contradiction; the paper itself only claims "competitive" later. The claim needs fixing, not hedging.

The Section 7 AutoML case study is confounded: embedding dimension goes from 6 to 16 and explicit feature crosses are removed along with the architecture change. The 0.01552 RIG lift cannot be attributed to DCN^2. That section should be rewritten as a migration story, not evidence for the architecture.

There are also no error bars or significance tests. Three runs are mentioned but only aggregates are shown. The online A/B numbers are aggregate lifts across many tests, with no duration, sample size, or significance information. For a revenue claim, that is thin.

What is genuinely good: the collision-weight idea is new to me, and the distribution analysis in Figure 5 is a nice touch. The paper is honest about the iPinYou result and the compute trade-off of onlydense. The inference engineering section is practical and specific. The citation pattern is fine; the self-citation to [12] is infrastructure, not method.

This is for practitioners working on CTR/CVR at scale, not for someone seeking a conceptual breakthrough. It is a legitimate industrial data point that a serious referee could improve substantially. As is, it is a conditional accept at best: add a matched-capacity baseline, fix the abstract, and de-confound or heavily caveat the AutoML section. I'd send it to peer review, but I'd expect major revision.

Referee Report

5 major / 5 minor

Summary. The paper proposes DCN^2, a modified version of the DCNv2 recommender architecture with three components: a per-lookup collision-weight column appended to the embedding table, an 'onlydense' cross layer that replaces DCNv2's low-rank projection, and a SimLayer that explicitly computes pairwise embedding similarities. The authors evaluate DCN^2 against DCNv2, FM, and deepFM on four public CTR datasets using single-pass streaming evaluation, and report production results including A/B lift and a deployment processing over 0.5 billion predictions per second. The central claim is that DCN^2 outperforms DCNv2 both offline and online by addressing information loss in Cross layers, collision handling, and missing pairwise interactions.

Significance. If the claims are substantiated, the work is practically significant: DCNv2 is a widely used industrial baseline, and the proposed modifications are simple enough to be adopted elsewhere. The paper's strengths include evaluation on four public datasets, a single-pass training setup matching production conditions, hash-space scaling experiments, and unusually detailed deployment engineering (inference optimization, A/B rollout, AutoML migration). The collision-weight mechanism is also presented as architecture-agnostic, which broadens its potential impact. However, as detailed below, the current evidence does not yet establish that the proposed mechanisms, rather than added capacity or confounding changes, drive the observed gains.

major comments (5)

[Abstract, Section 9, Table 1] The abstract states that 'the superior performance of DCN^2 is also demonstrated on four publicly available benchmark data sets,' but Table 1 shows DCN^2 with average AUC 0.7561 on iPinYou versus DCNv2's 0.7659, and DCN^2-simk at 0.7467. This directly contradicts the four-dataset claim and the statement in Section 9 that DCN^2 'consistently outperforms' baselines. Please revise the claim to acknowledge the iPinYou exception or provide a data-driven explanation for why this regime behaves differently.
[Section 3.2, Table 1] The onlydense layer replaces DCNv2's low-rank Cross layer of O(d·p) complexity with an O(d^2) dense projection, increasing parameter count and FLOPs. The benchmark comparisons in Table 1 do not match capacity, parameter count, or FLOPs across methods. Since the reported gains are small (around 0.002 AUC), the observed improvements could plausibly stem from added capacity or hyperparameter tuning rather than from the proposed interaction mechanism. Please add a matched-capacity DCNv2 baseline—for example, DCNv2 with a wider low-rank projection or larger embedding dimension—and report parameter and FLOP counts for each configuration.
[Section 4, Table 1] The paper says each experiment was repeated three times, but the reported statistics (avg, median, max, min, std) are computed over 20k-instance time windows within a single pass, not over the three seeds. No run-to-run variance, confidence intervals, or significance tests are provided. Given that the AUC differences between DCN^2 and DCNv2 are as small as 0.001–0.002 (e.g., Criteo 0.7933 vs 0.7922), the results may be within seed-level noise. Please report per-seed deviations or significance measures to support the claim of consistent improvement.
[Section 7] The AutoML migration case study changes two factors at once: the architecture becomes DCN^2, the embedding dimension increases from 6 to 16, and all explicit feature combinations are removed. The reported offline lift of 0.01552 RIG therefore cannot be attributed to the onlydense layer or the DCN^2 architecture alone. Please isolate the architectural contribution—for instance, by re-running the same pipeline with DCNv2 at embedding dimension 16—or explicitly characterize the result as an end-to-end pipeline lift rather than an architecture-only effect.
[Section 6] The online A/B results are presented only as aggregate lifts (3.2% RPM for CTR, 4.2% swCR and 0.37% GR for CVR) with no information about the number of tests, durations, sample sizes, confidence intervals, or guardrail metrics. The paper also says 'extensively A/B tested' without describing the experimental design. As written, the 'significantly out-performs' claim for online performance is not verifiable. Please provide standard A/B reporting details or temper the claim to 'directional positive results in production.'

minor comments (5)

[Section 3.1, Eq. (1)] The definition of X_ec is garbled: it contains the self-referential expression 'X[:, 1:d] = X[:, 1:d]' and the notation '-ω ≤ N(μ, σ²) ≤ ω' for a normal distribution is unclear. Please rewrite the initialization of the embedding table and weight column precisely as a partitioned matrix.
[Section 6] There is a typo: '0.5 billon predictions per second' should be '0.5 billion predictions per second.'
[Section 3.3] The text contains typos 'FFMSs' and 'simplifed'; also, the sentence 'the layer can be formulated as' introduces an equation with placeholder indices that should be fully defined, including the ranges of k' and the flattening mapping w_{k'(i,j)}.
[Section 4 and Section 6] Footnote 11 appears as a marker after 'single pass)11' but its text is missing from the manuscript, and Section 6's footnote 12 refers back to 'footnote 11 for details' about the KPIs. Please restore the missing footnote content and renumber.
[Section 3.2] The information-loss motivation for the onlydense layer is asserted rather than demonstrated; the footnote stating that a formal rank-nullity argument is beyond scope only emphasizes this. Since the paper does not provide empirical evidence of information loss in DCNv2's Cross layer, the motivation should be framed as a hypothesis, or supported by a small diagnostic experiment.

Circularity Check

0 steps flagged · score 0.0 of 10

No significant circularity; DCN2's reported gains are empirical and independently benchmarked.

full rationale

Walking the claimed derivation chain, no load-bearing step reduces to the paper's own inputs by construction. The three contributions — collision-weighted lookups, the onlydense layer, and the SimLayer — are defined as differentiable architectural components with explicit initializations, and the paper's evidence is external empirical comparison (Table 1, Figures 3–4, and Section 6 online A/B tests) rather than an equation whose output is fixed by a fitted constant or by definition. Collision weights start at 1.0 and are learned; the onlydense layer is a new O(d^2) dense projection with a scaled Hadamard product and no asserted equivalence to DCNv2's low-rank layer; SimLayer is an additive pairwise logit. The sole self-citation, [12], concerns the proprietary FwumiousWabbit inference service and deployment infrastructure, not the correctness or derivation of the architecture or benchmark results. Section 3.2 contains an explicitly omitted proof ('Formal argument for proving exact information loss bounds via Rank-Nullity Theorem is beyond the scope of this paper'), and Section 7's AutoML migration simultaneously changes embedding dimension from 6 to 16 and removes feature crosses, so the reported 0.01552 RIG lift is not cleanly attributable to the architecture alone; however, these are empirical attribution and motivation limitations, not circular reductions. Since the central comparisons are against external baselines with fixed AutoML budgets and the architecture's outputs are not defined in terms of the target metric, no circular step can be exhibited. Therefore the paper is self-contained with respect to circularity.

Assumptions & free parameters 4 free parameters · 4 assumptions · 2 invented entities

The paper introduces three new architectural mechanisms with their own learned parameters; none of the claims is derived from first principles, and the motivating premises (information loss, missing pairwise interactions) are asserted. The benchmark numbers depend on AutoML-selected hyperparameters that are not disclosed. No code or data artifacts are shipped.

free parameters (4)

per-lookup collision weight column = learned through backprop; initialized to 1.0
Adds a scalar multiplier for every entry in the embedding table (X_ec[:, d+1]); the claimed benefit comes from these weights changing during training.
onlydense scale factor phi = reported between 1.0 and 3.0 in practice
The layer scales the dense cross result by phi; the paper does not state whether it is learned or a hyperparameter, but it is an additional degree of freedom.
SimLayer per-pair weights w = learned, over-parameterized to one scalar per pair
Each (i,j) pair has its own scalar weight, acknowledged as redundant but kept for speed; this adds O(n^2) parameters essential to the explicit interaction term.
benchmark hyperparameters (LR, beta1, embedding dim) = not listed; selected by AutoML with one-hour budget per algorithm/data set
The paper reports only best configurations, not the chosen values or search details, which matters for reproducibility and for interpreting small AUC differences.

assumptions (4)

ad hoc to paper Cross layer information loss: the low-rank DCNv2 Cross projection compresses and loses information, motivating onlydense.
Section 3.2 asserts this and says the formal argument is beyond scope; no proof is given, yet it motivates a main architectural change.
ad hoc to paper DCNv2 does not model all pairwise interactions.
Section 3.3 claims this to justify SimLayer, but no formal comparison is shown; whether this is true determines the added value of SimLayer.
domain assumption Single-pass training is representative of production and fair across algorithms.
Section 4 justifies single-pass learning as reflecting production, but it can disadvantage some architectures and is not otherwise justified.
domain assumption Standard ML training assumptions: hash collisions are harmful and learnable weights mitigate them.
Section 3.1 relies on prior work [4,7] and the hash-space scaling experiment; not proven here, but plausible.

invented entities (2)

collision-weight column appended to the embedding table
purpose: Scalar per lookup that modulates the embedding before it enters the network
The paper introduces this as an intrinsic mechanism; the only supporting evidence is its own benchmark and weight-distribution analysis, with no external falsifiable prediction.
SimLayer pairwise interaction term
purpose: Explicit FFM-like dot-product logit added to the final prediction
Introduced to complement Deep/Cross; its benefit is measured only within the paper's own evaluations.

how reviews work

0 comments

Cite this review

Pith. "Pith review of DCN^2: Interplay of Implicit Collision Weights and Explicit Cross Layers for Large-Scale Recommendation." pith.science (2026). https://pith.science/paper/5DDRIWTX

@misc{pith2026250621624,
  author       = {Pith},
  title        = {Pith review of: DCN^2: Interplay of Implicit Collision Weights and Explicit Cross Layers for Large-Scale Recommendation},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/5DDRIWTX}},
  note         = {Machine review of arXiv:2506.21624}
}

read the original abstract

The Deep and Cross architecture (DCNv2) is a robust production baseline and is integral to numerous real-life recommender systems. Its inherent efficiency and ability to model interactions often result in models that are both simpler and highly competitive compared to more computationally demanding alternatives, such as Deep FFMs. In this work, we introduce three significant algorithmic improvements to the DCNv2 architecture, detailing their formulation and behavior at scale. The enhanced architecture we refer to as DCN^2 is actively used in a live recommender system, processing over 0.5 billion predictions per second across diverse use cases where it out-performed DCNv2, both offline and online (ab tests). These improvements effectively address key limitations observed in the DCNv2, including information loss in Cross layers, implicit management of collisions through learnable lookup-level weights, and explicit modeling of pairwise similarities with a custom layer that emulates FFMs' behavior. The superior performance of DCN^2 is also demonstrated on four publicly available benchmark data sets.

Figures

Figures reproduced from arXiv: 2506.21624 by the authors.

**Figure 1.** Architecture of DCN2 . Parts marked in green denote additions on top of DCNv2 [15] presented in this paper. arXiv:2506.21624v1 [cs.IR] 24 Jun 2025 [PITH_FULL_IMAGE:figures/full_fig_p001_1.png] view at source ↗

**Figure 2.** Example with two hidden onlydense layers. operation, followed by an anchor mapping achieved via a scaled Hadamard product4 . Note that the proposed layer does not perform element-wise summation, but performs only multiplication of the inputs with activated weight space of the same dimension, further scaled via a factor. Note also the absence of 𝑥𝑜 - the anchor multiplication considered by DCNv2 Cross layer – DCN2 o… view at source ↗

**Figure 3.** Expected AUC behavior (20k windows of instances) [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗

Figures from the paper (3 more)

**Figure 4.** Figure 4: Visualization of overall performance of different algorithms (single-pass) across different benchmark data sets. Kernel [PITH_FULL_IMAGE:figures/full_fig_p005_4.png]

**Figure 5.** Figure 5: Distribution of collision weights after a single pass [PITH_FULL_IMAGE:figures/full_fig_p005_5.png]

**Figure 6.** Figure 6: Inspecting introduced layers (pink) during infer [PITH_FULL_IMAGE:figures/full_fig_p006_6.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Building a User Foundation Model for the Open Web
cs.LG 2026-07 conditional novelty 5.0 of 10

A self-supervised Transformer on short open-web browsing sequences improves production CTR and win-rate models and delivers +2.13% live CTR under RTB latency and privacy constraints.

Reference graph

Works this paper leans on

20 extracted references · 14 canonical work pages · cited by 1 Pith paper

[12]

A Bag of Tricks for Scaling CPU-based Deep FFMs to more than 300m Predictions per Second

Škrlj, B., Ben-Shalom, B., Gašperšič, G., Schwartz, A., Hoseisi, R., Ziporin, N., Kopič, D., and Tori, A. A bag of tricks for scaling cpu-based deep ffms to more than 300m predictions per second. arXiv preprint arXiv:2407.10115 (2024)

work page Pith review arXiv 2024
[1]

Abadi, M., Agarwal, A., Barham, P., Brevdo, E., Chen, Z., Citro, C., Corrado, G. S., Davis, A., Dean, J., Devin, M., Ghemawat, S., Goodfellow, I., Harp, A., Irving, G., Isard, M., Jia, Y., Jozefowicz, R., Kaiser, L., Kudlur, M., Levenberg, J., Mané, D., Monga, R., Moore, S., Murray, D., Olah, C., Schuster, M., Shlens, J., Steiner, B., Sutskever, I., Talwa...

work page
[2]

Higher-order factorization machines

Blondel, M., Fujino, A., Ueda, N., and Ishihata, M. Higher-order factorization machines. Advances in neural information processing systems 29 (2016)

work page 2016
[3]

Recommender systems in the era of large language models (llms)

Fan, W. Recommender systems in the era of large language models (llms). IEEE Transactions on Knowledge and Data Engineering (2024), 1–20

work page 2024
[4]

B., Kamma, L., and Green Larsen, K

Freksen, C. B., Kamma, L., and Green Larsen, K. Fully understanding the hashing trick. Advances in Neural Information Processing Systems 31 (2018)

work page 2018
[5]

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 preprint arXiv:2203.15837 (2022)

arXiv 2022
[6]

Field-aware factorization machines for ctr prediction

Juan, Y., Zhuang, Y., Chin, W.-S., and Lin, C.-J. Field-aware factorization machines for ctr prediction. In Proceedings of the 10th ACM conference on recom- mender systems (2016), pp. 43–50

work page 2016
[7]

Embedding compression in recommender systems: A survey

Li, S., Guo, H., Tang, X., Tang, R., Hou, L., Li, R., and Zhang, R. Embedding compression in recommender systems: A survey. ACM Computing Surveys 56, 5 (2024), 1–21

work page 2024

Show all 20 references

[8]

Monolith: real time recommendation system with collisionless embedding table

Liu, Z., Zou, L., Zou, X., W ang, C., Zhang, B., Tang, D., Zhu, B., Zhu, Y., Wu, P., W ang, K., et al. Monolith: real time recommendation system with collisionless embedding table. arXiv preprint arXiv:2209.07663 (2022)

2022 arXiv
[9]

L., Zhao, W., Pan, S., Sun, Y., and Lu, Q

Pan, J., Xu, J., Ruiz, A. L., Zhao, W., Pan, S., Sun, Y., and Lu, Q. Field-weighted factorization machines for click-through rate prediction in display advertising. In Proceedings of the 2018 World Wide Web Conference (Republic and Canton of Geneva, CHE, 2018), WWW ’18, Intern...

2018
[10]

Factorization machines

Rendle, S. Factorization machines. In 2010 IEEE International conference on data mining (2010), IEEE, pp. 995–1000

2010
[11]

S., Benton, J., and Shlegeris, B

Scherlis, A., Sachan, K., Jermyn, A. S., Benton, J., and Shlegeris, B. Poly- semanticity and capacity in neural networks. arXiv preprint arXiv:2210.01892 (2022)

2022 arXiv
[13]

Autoint: Automatic feature interaction learning via self-attentive neural networks

Song, W., Shi, C., Xiao, Z., Duan, Z., Xu, Y., Zhang, M., and Tang, J. Autoint: Automatic feature interaction learning via self-attentive neural networks. In Proceedings of the 28th ACM international conference on information and knowledge management (2019), pp. 1161–1170

2019
[14]

Deep & cross network for ad click predictions

W ang, R., Fu, B., Fu, G., and W ang, M. Deep & cross network for ad click predictions. In Proceedings of the ADKDD’17 . 2017, pp. 1–7

2017
[15]

Dcn v2: Improved deep amp; cross network and practical lessons for web-scale learning to rank systems

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

2021
[16]

Graphfm: Graph factor- ization machines for feature interaction modelling

Wu, S., Li, Z., Su, Y., Cui, Z., Zhang, X., and W ang, L. Graphfm: Graph factor- ization machines for feature interaction modelling. Machine Intelligence Research (2025), 1–15

2025
[17]

Yi, J., Chen, Y., Li, J., Sett, S., and Y an, T. W. Predictive model performance: Of- fline and online evaluations. In Proceedings of the 19th ACM SIGKDD international conference on Knowledge discovery and data mining (2013), pp. 1294–1302

2013
[18]

Real-time bidding benchmarking with ipinyou dataset

Zhang, W., Yuan, S., W ang, J., and Shen, X. Real-time bidding benchmarking with ipinyou dataset. arXiv preprint arXiv:1407.7073 (2014)

2014 arXiv
[19]

Enhancing embedding represen- tation stability in recommendation systems with semantic id

Zheng, C., Huang, M., Pedchenko, D., Rangadurai, K., W ang, S., Nahum, G., Lei, J., Y ang, Y., Liu, T., Luo, Z., et al. Enhancing embedding represen- tation stability in recommendation systems with semantic id. arXiv preprint arXiv:2504.02137 (2025)

2025 arXiv
[2015]

Software available from tensorflow.org

Pith tools

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

[1] [12]

A Bag of Tricks for Scaling CPU-based Deep FFMs to more than 300m Predictions per Second

Škrlj, B., Ben-Shalom, B., Gašperšič, G., Schwartz, A., Hoseisi, R., Ziporin, N., Kopič, D., and Tori, A. A bag of tricks for scaling cpu-based deep ffms to more than 300m predictions per second. arXiv preprint arXiv:2407.10115 (2024)

work page Pith review arXiv 2024

[2] [1]

Abadi, M., Agarwal, A., Barham, P., Brevdo, E., Chen, Z., Citro, C., Corrado, G. S., Davis, A., Dean, J., Devin, M., Ghemawat, S., Goodfellow, I., Harp, A., Irving, G., Isard, M., Jia, Y., Jozefowicz, R., Kaiser, L., Kudlur, M., Levenberg, J., Mané, D., Monga, R., Moore, S., Murray, D., Olah, C., Schuster, M., Shlens, J., Steiner, B., Sutskever, I., Talwa...

work page

[3] [2]

Higher-order factorization machines

Blondel, M., Fujino, A., Ueda, N., and Ishihata, M. Higher-order factorization machines. Advances in neural information processing systems 29 (2016)

work page 2016

[4] [3]

Recommender systems in the era of large language models (llms)

Fan, W. Recommender systems in the era of large language models (llms). IEEE Transactions on Knowledge and Data Engineering (2024), 1–20

work page 2024

[5] [4]

B., Kamma, L., and Green Larsen, K

Freksen, C. B., Kamma, L., and Green Larsen, K. Fully understanding the hashing trick. Advances in Neural Information Processing Systems 31 (2018)

work page 2018

[6] [5]

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 preprint arXiv:2203.15837 (2022)

arXiv 2022

[7] [6]

Field-aware factorization machines for ctr prediction

Juan, Y., Zhuang, Y., Chin, W.-S., and Lin, C.-J. Field-aware factorization machines for ctr prediction. In Proceedings of the 10th ACM conference on recom- mender systems (2016), pp. 43–50

work page 2016

[8] [7]

Embedding compression in recommender systems: A survey

Li, S., Guo, H., Tang, X., Tang, R., Hou, L., Li, R., and Zhang, R. Embedding compression in recommender systems: A survey. ACM Computing Surveys 56, 5 (2024), 1–21

work page 2024