acceptodds
Under review as a conference paper at ICLR 2027

TGNN: Graph Neural Networks for Large-Scale Industrial Advertising Scenarios at Tencent

Abstract

Deploying Graph Neural Networks (GNNs) in industrial advertising is funda- mentally hindered by three intersecting challenges: extreme structural sparsity in cold-start scenarios, hundred-billion-edge scalability limits, and millisecond real-time serving constraints. We present TGNN, an industrial-scale GNN frame- work designed to systematically overcome these bottlenecks. To alleviate severe sparsity, where over 34% of graph nodes have a degree below five, TGNN leverages Large Language Models (LLMs) to construct semantically meaningful connec- tions among sparse nodes, combining this with fine-grained feature learning and cross-domain data augmentation to alleviate the sparsity issue. To support massive graphs exceeding 2 billion nodes and 100 billion edges, we design EasyGraph, a distributed graph database for efficient graph storage and sampling, and An- gelGraph, a large-scale graph computing platform that optimizes GNN training. Furthermore, we propose a hybrid stream-batch pipeline that guarantees strict temporal consistency and low-latency feature propagation. Online A/B testing demonstrates significant business gains: overall GMV increases by 3.43% (new advertisement 4.80%) in social feeds and by 2.77% (new advertisement 3.74%) in short-video feeds. TGNN provides a complete and highly scalable solution for deploying GNNs in real-world advertising recommendation systems.

Primary area:
learning on graphs and other geometries & topologies
Keywords:
Graph Neural Networks, Ad Recommender Systems, Heterogeneous Graph

Reviews

Among:
Shape:
1234this paper, Top 49%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.33 over 3 reviews, above 51% of the others.
Reviewer_9ot8OpenReview ↗
Rating
2
Confidence
2
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

TGNN combines LLM-derived semantic links, CPV tags, heterogeneous GNN learning, distributed graph infrastructure, and a stream-batch deployment pipeline for industrial ad retrieval. The paper evaluates the integrated system with offline comparisons, ablations, and online A/B tests. The main question is which claimed benefits are established for the full system and which are established for its individual components.

Critical strengths

S1. Strong offline results, with an informative ablation. TGNN substantially outperforms HAN on both industrial datasets (AUC 83.24 vs. 64.69 on A, and 85.29 vs. 71.42 on B). In the reported w/o-SE ablation, AUC falls to 65.81/69.84—roughly HAN’s level, slightly higher on A and lower on B. This suggests that the removed semantic components account for much of the offline gain.

S2. Encouraging results from production deployment. The randomized A/B tests complement the offline results. With equally sized buckets and the same retrieval quota, the paper reports overall GMV gains of 3.43% in social feeds and 2.77% in short video, with larger gains for new ads (4.80% and 3.74%).

Critical weaknesses

W1. The cold-start claim needs a more direct test. The w/o-SE result makes a good case that semantic enrichment helps overall, but the aggregate results do not show how much newly launched ads benefit. The paper does not clearly state whether w/o-SE removes both I2I and I2CPV edges, and it does not isolate the LLM encoder's gain over a simpler content encoder. Results grouped by ad age or interaction count, together with a matched encoder comparison, would make the cold-start claim more convincing.

W2. The online gains are encouraging, but more detail are needed to assess them. The paper says the A/B test lasted “several weeks” and gives point estimates, but not the exact duration, sample size, randomization unit, or uncertainty around the GMV gains. The new-ad gains come from deploying the full system, therefore a component-level test would be needed to attribute them specifically to semantic enrichment or warm-start.

W3. The theoretical bound appears inconsistent with the model definition. Eq. 5 sets r_a^1 = s_a, but Proposition 2.1 assumes ||r_a^l|| <= rho^l ||s_a|| for rho < 1. At l = 1, this cannot hold for a nonzero s_a, leaving the stated bound unsupported under the current indexing. For Eq. 11, the differentiated variable and the treatment of cosine normalization and batch averaging are not specified clearly. The proposed link between that gradient weight and node degree also lacks supporting evidence.

W4. Repeated full-scale industrial training may be costly, but the paper does not state whether Tables 1, 5, and 6 show single runs or averages, what randomness was controlled, or whether variability estimates are available, especially for the public benchmarks. Evaluation candidate and negative-set construction and public-benchmark settings also remain unclear. On Dataset A, TGNN's recall R@1(0.1095) exceeds its precision P@1 (0.1082), which is unexpected if both metrics use conventional definitions on the same query population. The metric formulas, populations, and aggregation rules are needed to interpret these entries and reproduce the public results.

W5. The system's cost is unclear. The paper targets a latency below 20 ms per request, but its sub-10-ms TP-999 result covers only two-hop graph sampling, leaving total request latency unknown. It describes when embeddings are refreshed, yet does not quantify the compute and storage needed to encode new ads or maintain semantic IDs, codebooks, and trie-based I2I links. This makes TGNN's operational cost difficult to assess.

W6. Inaccurate comparisons. For example, Table 3 listed LiGNN, GiGL, and EmbedX as homogeneous, but their papers describe heterogeneous support. https://dl.acm.org/doi/pdf/10.1145/3637528.3671566, https://dl.acm.org/doi/epdf/10.1145/3711896.3737229, and https://www.vldb.org/pvldb/vol16/p3543-shi.pdf.

Questions for authors

Q1: What exactly does w/o-SE remove both I2I and I2CPV edges, and any node features? Are there existing results by ad age or interaction count that show how much semantic enrichment helps newly launched ads?

Q2. How are Precision@1 and Recall@1 defined and aggregated, and how are evaluation candidates selected? In particular, why does Recall@1 exceed Precision@1 on Dataset A?

Q3. How much do semantic links improve outcomes for new ads beyond using their existing content features alone? In the equal-quota A/B test, how did impressions and GMV change for established ads with similar content? Were the new-ad gains accompanied by reduced exposure or GMV for those ads?

Q4. What is TGNN’s incremental cost relative to the deployed system, including complete request latency and the compute and storage needed for LLM encoding, semantic link maintenance, and training?

2 comments
AuthorsOpenReview ↗

Response to Reviewer 9ot8 (part 1)

We thank the reviewer for the thorough and precise comments.

W1 / Q1 / Q3 — Cold-start attribution.

w/o-SE removes both semantic edge families (I2I and I2CPV, leaving CPV nodes disconnected) while retaining all node features. Because sas_a is never used as a node feature (only to construct edges), the w/o-SE drop (−17.43-17.43 / −15.45-15.45 AUC on Datasets A / B) is strictly structural, on top of existing content features.

Semantic edges add 1.2×1091.2\times 10^9 edges covering 92% of ads (~13 edges per covered ad across ∣A∣>108\lvert\mathcal{A}\rvert > 10^8); note that our logs do not break this average down by ad age, so we do not have a separate per-new-ad edge count. These edges reduce the sparse-node ratio from 34.0% to 23.7% (I2I) and 11.8% (+CPV). We will add offline results grouped by ad age and interaction count (full TGNN vs. w/o-SE) in the revised version. We have not run a matched comparison against a smaller text encoder, so we cannot isolate the LLM's specific contribution from edge construction itself; we will state this explicitly.

W2 / Q3 — A/B test details and displacement of established ads.

  • Experimental setup: Randomization is at the user level (UV bucketing). Traffic ramped 5% →\to 20% →\to 80%, followed by a reversal returning 20% of users to control, with each stage lasting ≥1\ge 1 week (≥4\ge 4 weeks total). Arm sizes correspond to these production traffic shares. Variance is estimated via bucket jackknife, using finer buckets in final reports to control A/A false positives. Reported GMV lifts (+3.43% / +2.77%) come from the 20% stage. As a guardrail, any metric significantly negative at the 80% level is treated as a regression.
  • Displacement of established ads: Our online reports do not break impressions down by ad age, so we answer in terms of GMV. GMV is measured at the platform level (all ads, all traffic, all retrieval branches), whereas CTR/CTCVR are branch-level. Since new ads account for ~37% of platform GMV in control, the overall platform lift is a share-weighted average of new and established ads, implying that established ads also grew by roughly +2.6% / +2.2%. Thus, the gain is net incremental rather than a transfer from established ads. We agree that the online A/B test alone cannot isolate individual components; component attribution relies on the offline ablations.

W3 — Corrected Proposition 2.1.

The reviewer is right. Since ra1=sar_a^1 = s_a, the assumption must be written as ∥ral∥2≤ρl−1∥sa∥2\Vert r_a^{l}\Vert_2 \le \rho^{l-1}\Vert s_a\Vert_2. The resulting proof is both simpler and tighter: if ca1:ℓ=cb1:ℓc_a^{1:\ell} = c_b^{1:\ell}, Eq. 5 gives raℓ+1−rbℓ+1=sa−sbr_a^{\ell+1} - r_b^{\ell+1} = s_a - s_b, which implies ∥sa−sb∥2≤2ρℓ∥s∥2\Vert s_a - s_b\Vert_2 \le 2\rho^{\ell}\Vert s\Vert_2 and cos⁡(sa,sb)=1−∥sa−sb∥222∥s∥22≥1−2ρ2ℓ.\cos(s_a, s_b) = 1 - \frac{\Vert s_a - s_b\Vert_2^2}{2\Vert s\Vert_2^2} \ge 1 - 2\rho^{2\ell}. Hence, ℓmin⁡=⌈log⁡ρκ/2⌉\ell_{\min} = \lceil \log_\rho \sqrt{\kappa/2} \rceil guarantees cos⁡(sa,sb)≥1−κ\cos(s_a, s_b) \ge 1 - \kappa, remaining independent of ∣A∣\lvert\mathcal{A}\rvert. We will also explicitly clarify that sas_a in Eq. 5 denotes the 8-dim RQ-VAE latent (Fig. 1).

W3 — Gradient in Eq. 11.

Let u^i=ui/∥ui∥2\hat{u}_i = u_i / \Vert u_i \Vert_2 and pij=softmaxj(u^i⊤v^j/τ)p_{ij} = \mathrm{softmax}_j(\hat{u}_i^{\top}\hat{v}_j / \tau). Since uiu_i appears only in row ii of Eq. 10, the exact gradients are: ∂L∂u^i=−1Nτ((1−pii)v^i−∑j≠ipijv^j),∂L∂ui=I−u^iu^i⊤∥ui∥2∂L∂u^i.\frac{\partial \mathcal{L}}{\partial \hat{u}_i} = -\frac{1}{N\tau}\Big((1 - p_{ii})\hat{v}_i - \sum_{j \ne i} p_{ij}\hat{v}_j\Big), \quad \frac{\partial \mathcal{L}}{\partial u_i} = \frac{I - \hat{u}_i\hat{u}_i^{\top}}{\Vert u_i \Vert_2} \frac{\partial \mathcal{L}}{\partial \hat{u}_i}. We agree that the link between this gradient weight and node degree is an unsupported hypothesis, and we will remove that claim from the paper.

W4 / Q2 — Evaluation protocol and R@1 vs. P@1.

  • Runs & variance: Tables 1, 5, and 6 report single runs with date-fixed seeds. We will add mean ±\pm std over 5 random seeds on the public benchmarks.
  • R@1 exceeding P@1 on Dataset A: our P@K is not hits/K, and we should have defined it. Each test record is a labeled (user, ad) pair from day T+1 (1: interaction, 0: exposure without interaction). We rank the full ad pool by cosine and flag the pair if its ad is in the user's Top-K; then R@K=TP/(TP+FN)R@K=TP/(TP+FN) and P@K=TP/(TP+FP)P@K=TP/(TP+FP), summed over all pairs. R@K/P@KR@K/P@K is thus flagged pairs over positive pairs, not bounded by 1: R>PR>P in every row at K=20,100K=20,100, and at K=1K=1 only TGNN on A flags more pairs than positives (ratio 1.01). We will add these formulas and rename P@K to pair precision.
  • Negatives: Training uses 8 sampled negatives per positive. Public-benchmark settings are detailed in our reply to Reviewer nHF6 (W2).
AuthorsOpenReview ↗

Response to Reviewer 9ot8 (part 2)

W5 / Q4 — Incremental cost and end-to-end latency.

Two-hop graph sampling stays under 10 ms TP-999 within our 20 ms serving budget. Incremental operational resources are:

  1. LLM encoding: Streaming (~3×1053\times 10^5 ads/day), capped at 192 GPU-hours/day on a dedicated 8-GPU H20 node, with ~30 GPU-hours/day actually consumed (see reply to Reviewer GKub).
  2. Semantic IDs and trie: 10 bytes per ad (~1 GB for 10810^8 ads) plus 128 KB of codebooks, requiring under 1 CPU-hour/day.
  3. Graph storage: The 1.2×1091.2\times 10^9 semantic edges account for 1.2% of all edges (~15 GB).

W6 — Table 3 and readability.

The reviewer is right: LiGNN, GiGL, and EmbedX all support heterogeneous graphs. We apologize for this mischaracterization and will correct Table 3, restricting comparisons to dimensions directly verifiable from each paper. We will also consolidate mathematical notation across sections and move the missing experimental details into the main text to improve readability.

Reviewer_nHF6OpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

The paper presents TGNN, a deployed GNN framework for advertising retrieval on a platform with over 2 billion nodes and 100 billion edges. To address extreme sparsity (34% of nodes with degree below five), TGNN constructs semantic edges at launch time using LLM embeddings quantized by RQ-VAE into trie-based semantic IDs for item-to-item links (Eq. 5 to 7), plus hierarchical CPV tag edges weighted by IDF and recency (Eq. 8). Fine-grained feature learning uses noise-based augmentation with a three-level InfoNCE objective (Eq. 9 to 11), and cross-domain fusion relies on PEPNet gating with an ad-maturity gate that defaults fresh ads to the semantic expert (Eq. 12 to 15). The system layer (EasyGraph storage, AngelGraph training, hybrid stream-batch pipeline) sustains million-level QPS sampling with TP-999 latency under 10 ms and embedding refresh within 2 minutes. Offline next-day evaluation on two proprietary scenarios reports AUC 83.24 and 85.29, and online A/B tests report platform GMV lifts of 3.43% and 2.77%, with larger lifts for new advertisements.

Critical strengths
  1. This is a genuinely deployed system with decision-relevant evidence. The A/B design isolates the retrieval branch under an identical quota, reports branch-level and platform-level metrics separately, and shows the largest gains exactly where the design aims, namely new advertisements (+4.80% and +3.74% GMV) and the cumulative reduction of sparse nodes from 34.0% to 8.4% in Figure 3e. End-to-end evidence at this scale is rare in the GNN literature.
  2. The cold-start mechanism is structurally well thought out. Because semantic edges are independent of user behavior, a fresh ad receives messages from day one, and the maturity gate in Eq. 14 to 15 provides a continuous interpolation between the cold and warm regimes rather than a hard switch. Proposition 2.1 gives a concrete quality bound for the trie-based neighbor retrieval that makes the semantic-ID construction more than a heuristic.
Critical weaknesses
  1. The offline comparison does not isolate the modeling contribution. The external baselines (SimGCL, GraphSAGE, HAN) are weak choices for this setting, and the reported gap is implausibly large (+18.55 AUC over the strongest baseline in Table 1), which suggests the advantage mostly reflects features, graph access, and engineering rather than the architecture. The public benchmark check in Section 4.5 supports this reading, since TGNN is only marginally ahead there and trails XSimGCL on NDCG@20 for Yelp-2018 (0.0601 vs 0.0606).
  2. The individual components are existing techniques assembled, and the core claims are not externally verifiable. RQ-VAE semantic IDs, noise-based InfoNCE augmentation, and PEPNet gating all come from prior work, so the contribution is integration and scale rather than method design. The industrial results depend on a proprietary platform and unreleased logs, and with code release deferred to after publication, neither the A/B numbers nor the system performance claims can be checked.
Questions for authors

Refer to weaknesses.

1 comment
AuthorsOpenReview ↗

Response to Reviewer nHF6

We thank the reviewer for the critical reading. We agree with much of the diagnosis and will revise our claims accordingly.

W1 — Isolating the modeling contribution.

  • (i) Controlled baselines have no feature or graph-access disadvantage. SimGCL, GraphSAGE, and HAN are re-implemented on the exact same graph, features, negatives, and evaluation protocol as TGNN (Table 1 caption).
  • (ii) Source of the +18.55 AUC gain. We agree this gain does not come from the GNN backbone. Table 5 demonstrates this directly:
ModelAUC (A)AUC (B)
HAN64.6971.42
TGNN w/o semantic edges65.8169.84
TGNN w/o contrastive module71.6371.55
TGNN w/o PEPNet gating73.0674.28
TGNN83.2485.29

Without semantic edges, TGNN matches HAN; semantic-edge construction accounts for +17.43 / +15.45 AUC. The contrastive and gating modules become effective only on top of these edges, because Lcross\mathcal{L}_{cross} requires a semantic view to align with and the maturity gate relies on the shared semantic expert. This dependency explains why single-component ablations are super-additive. We therefore view the result as a joint modeling-and-system gain: semantic densification is the modeling contribution, made practical at 2B nodes only because neighbor construction costs O(M)O(M) per ad and EasyGraph samples the densified graph under 10 ms TP-999. We will revise Sec. 4 to state this clearly.

  • (iii) Public benchmarks. With ID-only features, there is no text, CPV, or multi-domain signal, so the components driving our industrial gains are inactive. Even so, the remaining backbone and contrastive objective still achieve +22.1% / +11.6% Recall@20 over XSimGCL on Amazon Books / Yelp-2018, with NDCG@20 on Yelp within 0.0005 (0.0601 vs. 0.0606).
  • (iv) Semantics as topology, not as features. We have not run a baseline that feeds sas_a directly as a node feature, and we do not claim one. However, our ablation confirms the gain is not a node-feature effect: sas_a is never used as a node feature in TGNN (only to build edges), and w/o-SE retains all existing node features while removing only the semantic edges. The −17.43-17.43 / −15.45-15.45 AUC drop is thus attributable to the added graph topology on top of existing ad content features.

W2 — Novelty. We agree that RQ-VAE, InfoNCE, and PEPNet are established building blocks, and we will reframe the paper around three specific contributions:

  1. Turning content semantics into graph topology for cold-start ads: Prior industrial applications of RQ-VAE semantic IDs use them as generation targets for trie-constrained decoding. In contrast, we use shared ID prefixes to construct graph edges with a formal similarity guarantee (corrected Prop. 2.1: cos⁡(sa,sb)≥1−2ρ2ℓ\cos(s_a, s_b) \ge 1 - 2\rho^{2\ell} for common-prefix depth ℓ\ell), reducing neighbor construction from O(∣A∣log⁡∣A∣)O(\lvert\mathcal{A}\rvert \log \lvert\mathcal{A}\rvert) to O(M)O(M) per ad.
  2. Characterization of component synergy on sparse graphs: Demonstrating that cross-view contrast and maturity-gated fusion yield substantial gains only after a semantic view is established.
  3. End-to-end industrial validation: Quantified densification (sparse-node ratio reduced from 34.0% to 23.7% via semantic edges alone, and to 8.4% with CPV tags and cross-domain behavior edges) paired with new-ad GMV lifts (+4.80% / +3.74%) that exceed overall lifts (+3.43% / +2.77%), directly matching the proposed mechanism.

W2 — Verifiability. Production logs cannot be released due to user-privacy restrictions. The detailed experimental configurations are as follows:

  • Public benchmark configuration: ID-only features; meta-paths user-item-user / item-user-item; hidden dim 64; 128 negatives; Adam optimizer, lr 10−310^{-3}, no weight decay; 600 epochs; batch size 1024. Amazon Books uses output dim 128 and fan-out 100/100; Yelp-2018 uses output dim 64 and fan-out 2400/1500.
  • Industrial semantic-ID configuration: Templated ad text encoded by frozen Hunyuan-Large; RQ-VAE with an 8-dim latent, M=4M=4 layers of K=1024K=1024 codewords, and length-5 IDs (including one disambiguation code).
  • Online A/B test details: Duration, randomization unit, sample size, and confidence intervals are provided in our reply to Reviewer 9ot8 and will be added to the paper.
Reviewer_GKubOpenReview ↗
Rating
3
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper presents TGNN, a system-algorithm co-designed GNN framework tailored for ultra-large-scale industrial advertising recommendation systems (deploying across social-feed and short-video platforms with >2 billion nodes and >100 billion edges). The paper addresses three core challenges in real-world ad recommendation: severe structural data sparsity (e.g., cold-start items and low-degree nodes), hundred-billion-edge scalability, and low-latency real-time serving (<20 ms latency, <5 min freshness SLA).

Critical strengths

S1. TGNN does not treat model architecture and infrastructure in isolation. The synergy between algorithmic requirements and infrastructure capabilities represents a top-tier industrial machine learning contribution.

S2. The construction of semantic I2I edges via LLM representations, RQ-VAE residual quantization, and Trie-tree lookup is well-engineered. Bounding the retrieval complexity to O(M) while providing a theoretical guarantee on semantic similarity preservation (Proposition 2.1) is mathematically sound and practical.

S3. The paper validates performance at an impressive scale, millions of sampling QPS with TP-999 latency <10 ms). The online A/B testing yields significant revenue (GMV) and conversion rate improvements across user activity strata, particularly for cold-start new advertisements (+4.80% / +3.74% GMV lift).

Critical weaknesses

W1. In Table 1 and Table 5, the production baseline HiGNN exhibits surprisingly poor metrics (e.g., AUC of 59.57% on Dataset A and 58.81% on Dataset B vs. TGNN's 83.24% and 85.29%). Such a massive gap (~24-26 AUC points) suggests that HiGNN might be lacking fundamental dense/semantic features or proper tuning, which warrants clarification to prevent misinterpreting the relative gain attributable solely to the GNN architecture.

W2. While the inference cost of Trie-based traversal is O(M), generating s_a=LLM(x_a) for hundreds of millions of ads daily requires non-trivial computational budget. The paper lacks a detailed breakdown of the offline/near-line LLM inference latencies and resource overheads.

W3. Equations 4 and 10 use sampled-softmax and InfoNCE losses. In dense industrial graphs, randomly sampled items in a mini-batch frequently serve as false negatives (e.g., unobserved items that the user would actually like). The paper does not discuss or deploy false-negative filtering or hard-negative correction techniques for L_{ssl} ​ W4. Although algorithmic components (semantic edges, contrastive module, PEPNet gating) undergo rigorous ablation in Section 4.2, the empirical trade-offs of key system parameters—such as B-Tree branching factors, request coalescing batch sizes, or MVCC window limits—are described qualitatively rather than quantified via micro-benchmarks.

Questions for authors

D1. Could you clarify why the production baseline HiGNN yields an AUC around ~59%, whereas external GNN baselines like HAN achieve ~64-71% and TGNN reaches ~83-85%? Did HiGNN operate without the fine-grained feature embeddings available to the other models?

D2. What specific LLM backbone is used for s_a=LLM(x_a) ? How often is this embedding computed for updated or newly introduced ad creatives, and what is the computational latency/cost associated with this step?

D3. In Proposition 2.1, how closely does the empirical residual decay factor ρ match the theoretical geometric decay assumption in practice across your codebook layers (M)?

D4. When a new advertisement is initialized mid-day, how quickly are its LLM-based I2I and I2CPV semantic edges ingested into EasyGraph's W-Cache, and does this trigger any re-indexing of the Trie tree?

D5. Did you observe any false-negative push-away effect in L_{cross} or L_{intra} when contrasting behavior and semantic views for highly popular items?

2 comments
AuthorsOpenReview ↗

Response to Reviewer GKub (part 1)

We thank the reviewer for the careful reading and constructive feedback.

W1 / D1 — Why HiGNN achieves ~59% AUC. To answer D1 directly: yes. HiGNN runs in its production configuration on a two-hop behavior-only graph without the dense semantic features provided to the other models. Consequently, the 24–26 point AUC gap is not purely an architectural gain, and we will state this explicitly in the revision. HiGNN is also calibrated for head-of-ranking precision, which explains why it remains competitive on P@1/P@20 despite lower AUC and Recall (App. C.3).

The controlled comparison is against SimGCL, GraphSAGE, and HAN, which are re-implemented on the exact same graph, features, negative samples, and evaluation protocol as TGNN, eliminating any feature asymmetry. The gain decomposition (Table 5) is summarized below:

ModelAUC (A)AUC (B)
HAN64.6971.42
TGNN w/o semantic edges65.8169.84
TGNN83.2485.29

Without semantic edges, TGNN performs on par with HAN. The improvement stems from semantic-edge densification; the contrastive and gating modules pay off only once a semantic view exists (Lcross\mathcal{L}_{cross} aligns the behavior and semantic views, and the maturity gate relies on the shared semantic expert).

W2 / D2 — LLM encoder and its cost. The input xax_a is a templated ad text (name, product type, categories, and attribute tags) encoded by the frozen open-weight Hunyuan-Large (MoE, 389B total / 52B active parameters). The encoder is never on the online serving path: the 3.4×10103.4\times 10^{10} daily requests read cached embeddings. Each ad is encoded once and cached, so coverage accumulates over time.

  • Trigger & frequency: Encoding is streaming and triggered by the Ad Change Log (same as GNN item embeddings in Sec. 3). Editing an ad's copy or creative goes through the publishing pipeline and produces a new ad ID, which is encoded as a new ad; thus, every creation or edit triggers exactly one encoding and no ad is ever re-encoded.
  • Throughput & compute cost: This yields roughly 3×1053\times 10^5 encodings/day under a 240 requests/min quota (4 ads/s), comfortably above the average rate of 3.5 ads/s. With FP8 weights, the model fits on a single 8-GPU H20 node (at most 192 GPU-hours/day dedicated); at ~300 prompt tokens per ad, actual compute consumption is ~30 GPU-hours/day. RQ-VAE assignment and trie insertion take O(M)O(M) per ad. We will add these details to App. B.1.

W3 / D5 — False negatives in Eqs. 4 and 10. We agree and do not claim to have solved this issue; sampled and in-batch negatives indeed contain unobserved positives. We conducted an offline study applying false-negative correction for low-interaction items, which produced a seesaw effect across the two scenarios (absolute change vs. TGNN):

  • Dataset A: AUC −0.005-0.005, Recall@20 −0.009-0.009.
  • Dataset B: AUC +0.007+0.007, Recall@20 +0.013+0.013.

Because the correction improves one scenario at the expense of the other, it is not deployed and remains under investigation. On D5 specifically, we did not separately measure the push-away effect for highly popular items, so we cannot confirm that mechanism; the seesaw we observed occurs at the scenario level. We will report this transparently as an open limitation rather than a component of TGNN.

W4 — System micro-benchmarks. We do not have parameter-sweep micro-benchmarks for B-Tree fan-out, coalescing batch size, or MVCC window limits, as these parameters were fixed during production deployment rather than swept. We will state this explicitly as a limitation instead of describing the trade-offs qualitatively. What we did measure is the end-to-end impact of each optimization: request coalescing reduces TP-999 latency by 10%, 3.8x feature compression reduces it by a further 10%, and 2-hop (5x5) sampling stays under 10 ms TP-999.

D3 — Empirical ρ\rho in Proposition 2.1. As Reviewer 9ot8 also noted, since ra1=sar_a^1 = s_a, the assumption must read ∥ral∥2≤ρl−1∥sa∥2\Vert r_a^{l}\Vert_2 \le \rho^{l-1}\Vert s_a\Vert_2, which yields a simpler and tighter bound: cos⁡(sa,sb)≥1−2ρ2ℓ\cos(s_a, s_b) \ge 1 - 2\rho^{2\ell} (full derivation in our reply to Reviewer 9ot8). Here, sas_a is the 8-dim RQ-VAE latent quantized by M=4M=4 layers of K=1024K=1024 codewords plus one disambiguation code (0≤ℓ≤40 \le \ell \le 4). Empirically, the per-layer ratios ∥rl+1∥2/∥rl∥2\Vert r^{l+1}\Vert_2 / \Vert r^{l}\Vert_2 are [values], giving ρ^=\hat{\rho} = [value]; the decay is [close to geometric / slower at deeper layers]. We will include a plot comparing predicted vs. measured cosine similarity across prefix depths.

AuthorsOpenReview ↗

Response to Reviewer GKub (part 2)

D4 — New ads added mid-day. Both the LLM and the RQ-VAE codebooks are frozen, so no trie re-indexing is triggered. When a new ad is created mid-day, the Ad Change Log triggers encoding, quantization with the fixed codebooks, trie insertion (adding at most M+1=5M+1 = 5 nodes: four codes plus one disambiguation code), and linking to the Top-DD ads sharing its deepest prefix. The resulting I2I and I2CPV edges are written to W-Cache and replicated to R-Cache via the WAL. Semantic edges therefore take effect immediately upon encoding completion without periodic rebuilds, while the ad embedding itself is refreshed near-line (within 2 minutes) from its features and existing edges.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.