HGenPush: A Heterogeneous Generative Recommendation Architecture for Industrial Push Notification Systems

42 minread-scoreDeep dives
Contents · 9 sections1What problem is it actually solving?2The overall flow: one backbone, two branches, plus a reinforcement learning step3Chained-MTP: how are three ID levels computed in one forward pass?4The author branch: how do the IDs come to reflect who trusts an author?5UCPA: how does post-click behavior correct clickbait?6What do the experiments show?7Limitations as I see them8How a recommendation team could try it9Overall assessment

Recommendation teams that run generative retrieval and are held back by online throughput should read this paper. Its value is not one more generative recommender. It is a practical engineering trade-off: the levels of a multi-level Semantic ID are no longer produced by rerunning the Transformer once per level, but by one forward pass plus a few small networks, with almost no loss in hit rate and a clear gain in throughput. The core idea in one sentence: a single model generates two kinds of candidates, "which video to push" and "which author to push", and is then fine-tuned with reinforcement learning on what users actually watch after they open a push. The paper comes from Kuaishou's push notification system and calls the model HGenPush (Heterogeneous Generative Push). Against the previous multi-stage architecture, online DAU rose 0.181% and CTR rose 1.577%. When the way the ID levels are predicted switches from a level-by-level Transformer to the paper's Chained-MTP, max QPS per device goes from 1.27k to 1.70k, while HitRate@100 only moves from 0.3954 to 0.3915. All evidence comes from a single Kuaishou push scenario with no public-dataset results, and some online metrics of the full model are not statistically significant, as discussed below.

What problem is it actually solving?

Start with an illustrative scenario. A user often watches cooking videos. Two authors on the platform, A and B, both make home-cooking videos in almost the same category. This user only ever follows A: whenever A posts, he opens it and watches to the end, while B's videos get swiped away quickly. The push system can send him only a few notifications a day, and one bad pick may make him turn notifications off.

This scenario exposes three problems of current generative recommendation.

First, it recommends videos but not authors. Methods such as TIGER and OneRec represent each video as several levels of Semantic ID and let the model generate a video's IDs. A's and B's videos have similar content and therefore similar IDs, so video IDs alone can hardly learn that this user trusts A and not B. In the paper's words, trust in an author shows up in behavior and cannot be inferred from content alone.

Second, level-by-level generation is slow. Multi-level IDs are usually generated one level at a time, and each level means another pass through the model. A push run must compute candidates for a very large number of users, and a retrieval step that is too slow cannot replace the existing multi-stage pipeline.

Third, training on clicks alone tends to learn clickbait. If a user opens a push and swipes away after a few seconds, that recommendation actually failed. Whether the user finishes, likes, or forwards the video after opening it is closer to the content's real value.

The overall flow: one backbone, two branches, plus a reinforcement learning step

Paper Figure 1: the overall HGenPush architecture. On the left, the user's four behavior sequences and static features are joined into one long sequence with two special tokens at the end; top right are the video branch and the author branch, each starting from the output of its own special token; bottom right is preference alignment using post-click viewing behavior. "\" marks where gradients are stopped.
Paper Figure 1: the overall HGenPush architecture. On the left, the user's four behavior sequences and static features are joined into one long sequence with two special tokens at the end; top right are the video branch and the author branch, each starting from the output of its own special token; bottom right is preference alignment using post-click viewing behavior. "\" marks where gradients are stopped.

The division of labor is summarized in this table, and each part is unpacked below.

ComponentInputOutputWhat it solves
User behavior understanding (backbone)Long- and short-term feed behavior, push click sequence, push send sequence, static features such as age and genderOutput vectors of two special tokens, each a summary of user interestCombines behavior from several scenarios
Video branchThe vector of the video-branch special tokenThe video's 3 ID levelsChained-MTP computes them in one pass, fixing slow level-by-level generation
Author branchThe vector of the author-branch special tokenThe author's 2 ID levels followed by the video's first-level IDRecommends authors, not only videos
UCPAVideos watched in the visit after a push is opened, with their behavior labelsA reinforcement learning update of the video branchClicks alone lead to clickbait

The backbone is a decoder-only Transformer with 16 layers and dimension 512. Each video in a sequence first gets a set of feature embeddings, concatenated and projected to a 512-dimensional vector, but the two kinds of sequence use different features. Videos in the long- and short-term feed behavior use Semantic ID, author ID, topic tag and playtime. Videos in the push click and push send sequences use Semantic ID, author ID and notification type, and the notification type lets the model learn which notification formats this user is more willing to open. The four sequences and the static features form one long sequence, and two special tokens are appended at the end, one for the author branch and one for the video branch. Because attention is causal, these two final tokens see every earlier behavior, and their outputs serve as two summaries of user interest.

Why decoder-only? The paper compares it with an encoder-decoder version. The encoder-decoder model has 0.026B parameters and a HitRate@100 of 0.3400. The decoder-only model has 0.016B parameters and 0.3432. So parameters drop from 0.026B to 0.016B while hit rate is slightly higher, and the authors chose the structure that uses less memory and runs faster. The decoder-only numbers here, 0.016B and 0.3432, are the same as the smallest size in the later scaling experiment (8 layers, 256 dimensions). So this comparison was run at the smaller size, not on the final 16-layer backbone.

Chained-MTP: how are three ID levels computed in one forward pass?

A video's ID has 3 levels, each with 8192 values, generated from the video's multimodal embedding in the same way as OneRec. These IDs are both the input feature of each video in the behavior sequences and the target the video branch generates. The usual approach generates level 1, feeds it back as input, reruns the Transformer to generate level 2, and so on. Chained-MTP runs the Transformer only once to get the output vector of the video-branch special token. After that, each level uses only a small feed-forward network.

Here is the level- ID, is an embedding table dedicated to level- IDs, and is the feed-forward network for level . The intuition: the user-interest vector never changes and works as a fixed anchor. Each ID already chosen at an earlier level is looked up in its table, and the resulting vector is added to , telling level what was chosen before.

An illustrative walk-through: level 1 passes through and picks ID 37 (illustrative). Level 2 adds the vector for ID 37 from the level-1 table to , passes it through , and picks 1024 (illustrative). Level 3 adds both the ID-37 and ID-1024 vectors to and passes the sum through . All three steps are a vector addition and a small network; the 16-layer Transformer is not run again. In training, each level has its own cross-entropy loss, and their sum is the video-branch loss. Training samples come from push click data.

Why not predict the three levels independently? The paper compares three ways:

MethodHitRate@100Max QPS per device
Each level predicted independently (Parallel-MTP)0.11502.40k
Level by level with a Transformer (DeepSeek-MTP)0.39541.27k
Chained-MTP0.39151.70k

Fully independent levels are the fastest, but hit rate falls to 0.1150. This shows that levels 2 and 3 must know what was chosen earlier; that dependency cannot be dropped. The level-by-level Transformer has the best hit rate, but its throughput is 47.09% lower than independent prediction. Chained-MTP keeps the dependency between levels with only table lookups and additions, gaining 33.86% throughput over the level-by-level Transformer while hit rate only moves from 0.3954 to 0.3915. The QPS here is measured on the full model with both branches, which is closer to the real deployment cost.

The author branch: how do the IDs come to reflect who trusts an author?

If an author's ID were built directly from content features, A and B would get similar IDs, and we would be back to the problem in the first section. The author branch solves this in three steps.

Step one aligns the author vector with user interest. Author ID and multimodal embeddings are encoded into an author vector, and it is projected into the same space as the user-interest vector from the author-branch special token. Training uses contrastive learning: within a batch, the user is pulled toward the author he actually clicked and pushed away from the authors clicked by other users in the batch. In the learned author vectors, being close means "opened by the same kind of users", not just "posting the same kind of content". In the illustrative scenario, A and B make similar content, but the users who click A are not the users who click B, so their vectors are pushed apart.

Step two encodes the aligned author vector into a 2-level ID, each level with 8192 values. It uses RQ-KMeans: level 1 finds the center nearest to the author vector, records its index, and subtracts that center to get a residual; level 2 finds the nearest center to the residual. The codebook is trained and updated together with the model, with a loss equal to the distance from each level's residual to its chosen center. In each training sample, the target author's 2-level ID is computed with the codebook as it stands at that point, using the two steps above. To keep most IDs from going unused, the paper uses the SimVQ approach. The codebook is written as a fixed table multiplied by a learnable matrix, and training updates that matrix. All code vectors move together, so no ID stays frozen just because it was never picked.

Step three sets the generation target to "author ID + the video's level-1 ID", 3 positions in total. The author branch ultimately recommends one video by this author, so appending the video's level-1 ID answers both "which author" and "what kind of content from him". These 3 positions are also generated with Chained-MTP, and beam search returns several such ID groups as candidates. Note that the source's description stops at the beam search candidates going straight into ranking. Whether author IDs are unique, and how mixed semantic IDs map back to an author and expand into concrete video candidates, is left open.

UCPA: how does post-click behavior correct clickbait?

Trained on clicks alone, the model leans toward content that is easy to open. The paper calls this step UCPA (User Consumption Preference Alignment). Its idea is to treat the videos watched in the visit after a push is opened as one group, score them by behavior, compare them within the group, and use reinforcement learning to push the model toward the better ones.

The scoring rule is fixed and adds up the behavior labels already in the platform logs, once per label a video has:

Behavior labelScore
Valid play, entering the author's profile, staying in comments+2 each
Like, follow, share, comment+1 each
Short play (swiped away quickly)−2
Dislike−5
Report−10

The paper explains that positive scores reward content users want to watch and negative scores push down low-quality or disliked videos. Each group has at most 50 videos. Within a group, each score minus the mean, divided by the standard deviation, gives how much better a video is than the group average, called its advantage.

An illustrative example: a visit includes three videos. Video X has a valid play and a like, scoring 3. Video Y is a short play, scoring −2. Video Z has a valid play, a profile visit and a share, scoring 5. The mean is 2 and the standard deviation is about 2.94, so the advantages are about 0.34, −1.36 and 1.02. The update raises the generation probability of Z and X and lowers that of Y.

The paper calls its optimizer GSISPO, which combines ideas from two existing reinforcement learning methods: GSPO (a method that computes the new-to-old probability ratio over the whole output rather than per token) and CISPO (a method that clips that probability ratio so gradients are preserved). In the formula, the generation probabilities of all videos in a group are conditioned on the same video-branch user-interest vector; the formula does not use a different vector per video. For this group's importance sampling, whether the behavior input of this user-interest vector ends before the click, after the click, or at the end of the session (the visit) is left open in the source. For each video it first computes the new-to-old probability ratio at each of the 3 ID levels, then takes their geometric mean. Why over the whole sequence? The advantage belongs to the whole video and should not be split across single IDs. Also, in Chained-MTP only the full 3-level ID corresponds to a whole video, and the paper argues that computing over the full sequence avoids breaking up the meaning of that ID and makes training more stable. The ratio is clipped to , but it is used only as a weight with no gradient, and the gradient flows through the log probability. The paper's reason is that samples outside the range still contribute gradient, so niche but high-value behaviors are not simply discarded.

No extra KL constraint is added to the reinforcement learning term, because the video branch's original cross-entropy loss is trained alongside it and keeps the model stable. The source's total-loss formula sums four terms: video generation, author generation, author codebook updates, and GSISPO. The contrastive loss for author alignment is given separately in the author-branch section, and the source describes the author branch as end-to-end, learning author vectors and author generation at the same time. At inference both branches use beam search to produce multiple candidates, which go straight into the ranking stage, skipping pre-ranking.

What do the experiments show?

The data comes from Kuaishou's push system, covering over 400 million daily active users, and models are trained continuously on online streaming data. Offline evaluation loads each model's checkpoint saved at the same time and measures HitRate@100 on the same dataset collected online.

ModelVideo branchAuthor branch
SASRec0.30930.3495
TIGER0.38020.4677
HGenPush0.39150.4848

HGenPush is best on both branches. Note that the author branch's target is the 3-position mixed ID while the video branch's is the 3-level video ID, so the two columns cannot be compared with each other. The only baselines are SASRec and TIGER; newer industrial methods such as OneRec are not included.

Paper Figure 2: offline performance at different model sizes. Across the three parameter sizes, HitRate@100 rises a lot from the first to the second and flattens clearly from the second to the third.
Paper Figure 2: offline performance at different model sizes. Across the three parameter sizes, HitRate@100 rises a lot from the first to the second and flattens clearly from the second to the third.

On scale, growing the model from 0.016B (8 layers, 256 dimensions) to 0.064B (16 layers, 512 dimensions) lifts HitRate@100 from 0.3432 to 0.3915, a 14.07% relative gain. Replacing the feed-forward layers with sparse experts to reach 0.170B brings it to 0.4043, only a further 3.27%. The 16 layers and 512 dimensions in the implementation details match the 0.064B size. This shows diminishing returns from adding parameters in this range.

The offline comparison for preference alignment is the most telling. The click-only baseline has a HitRate@100 of 0.3964. Reweighting training samples directly by watch time drops it to 0.3394, which shows that this reweighting disrupts the main objective of predicting what users will click. UCPA gives 0.3915. Direct reweighting distorts the main training objective, while within-group comparison only moves hit rate from 0.3964 to 0.3915 and brings in more consumption signals. In online A/B tests, adding UCPA versus the click-only version raised forward rate by 7.57% and complete play rate by 0.90%. This means users not only opened the push but were more willing to finish and share the video.

The final online experiment ran in three steps, each against the previous multi-stage architecture, with p-values in parentheses:

VersionDAUCTRApp usage duration
v1: video branch only+0.126% (0.00)+0.998% (0.00)+0.095% (0.01)
v2: v1 plus UCPA+0.153% (0.00)+1.075% (0.02)+0.145% (0.05)
v3: v2 plus author branch (full model)+0.181% (0.04)+1.577% (0.11)+0.148% (0.75)

The numbers rise at each step, but the p-values call for caution. All three v1 metrics are significant. For the full model, DAU has p = 0.04, CTR has p = 0.11 and usage duration has p = 0.75, and the last two are not significant at the usual 0.05 level. Also, every version is compared only with the old production system; v3 is never compared directly with v2. So for the gain from the author branch, this table shows a consistent direction, not a confirmed effect.

Limitations as I see them

First, the evidence for the author branch is the weakest. Offline, the author branch's HitRate@100 is 0.4848 against TIGER's 0.4677, a small gap. Online, after adding it, CTR has p = 0.11 and usage duration has p = 0.75, yet it is exactly the "heterogeneous" part of the title.

Second, UCPA's scoring rule is one hand-set table of fixed values, such as −10 for a report and −2 for a short play. The experiments use only this one rule, and different values could change what preferences the model learns.

Third, all results come from a single Kuaishou push scenario, with data and engineering stack kept internal. Push has frequency limits, and feedback density differs from the feed, so other scenarios need fresh validation. Candidates skip pre-ranking and go straight to ranking, so the ranking stage handles more candidates, and that cost is not visible in the experiments.

How a recommendation team could try it

  1. A team that already has Semantic ID generative retrieval can first swap the multi-level ID prediction to Chained-MTP offline and compare HitRate and per-device QPS against the current level-by-level generation. The change is only in the output head, and the backbone stays the same. If hit rate stays within a few thousandths and throughput rises clearly, it is worth an online test.
  2. A team with post-click behavior logs should not reweight samples directly by watch time; this paper's offline results show it hurts the main objective. Instead, follow UCPA: group by visit, standardize within the group, run reinforcement learning, and check how much hit rate drops and how much consumption metrics rise.
  3. Try the author branch only when the platform has clear authors or shops and users have stable preferences for sources. Start with just "align author vectors with user interest, then encode them into IDs", and check whether the IDs separate authors with similar content but different audiences. Online, run the experiment long enough and with enough samples to avoid the non-significant p-values seen here.

Overall assessment

The key takeaway is that the dependency between ID levels can be kept with table lookups and additions alone, without rerunning a large model for every level.

DimensionAssessment
Importance of the problemMedium-high. Inference cost is the main barrier to deploying generative retrieval, and push is especially latency-sensitive
Novelty of the methodMedium. Chained-MTP is simple and effective; the author branch and GSISPO mainly combine existing methods
Experimental evidenceMedium. Throughput and ablation data are clear, but there is only one internal scenario and some full-model online metrics are not significant
Engineering costLow to medium. Chained-MTP only changes the output head; UCPA needs post-click behavior logs
Worth tryingYes. Try Chained-MTP first; decide on the author branch based on the platform

How did this read for you?

One tap, no sign-in; tap again to undo. Only anonymous counts are kept, never who you are.

Discussion

Add experiment details, reproduction notes or a different take. Requires a GitHub sign-in.

Loading the discussion…