UGR: Unified Generative Ranking for Heterogeneous E-commerce Recommendation

Taobao's generative ranking framework UGR has one generative model directly produce the screen the user finally sees: the roughly one thousand organic, ad and other-business candidates of a request go to the model together, and it generates the final list item by item, instead of each business ranking its own items and a blending stage stitching them together. That stitching step is the old problem: the blender inserts other content into the generator's list, positions and context change, and what the model learned about which item follows which no longer holds. Training goes beyond imitating logged exposure sequences: samples are weighted by post-exposure clicks and purchases, and the model also learns which of two orderings is better. Ads keep the existing allocation rules and ad auction (GSP) pricing rules. In an online A/B test on Guess You Like, transaction volume rose 3.29% and GMV rose 2.10%. When the same model ranks only organic items and hands them to the old blender, transaction volume rises only 2.84%, and the gap is the value of unified generation itself. Teams that rerank e-commerce feeds, especially feeds where one screen mixes ads with items from several businesses, should read it: the generation architecture and preference training are known ideas, and UGR's contribution is making the generated list the final screen while shipping under the existing ad auction rules.

What problem is it actually solving?

Take an illustrative case. A user opens the Guess You Like feed, and the screen has four slots. The organic generative ranker has already ordered four items, and then the blender inserts an ad and a card from another business:

When the generator placed socks B, it assumed B sat right after shoe A. After blending, B is pushed to slot 4, behind a competing shoe and a live-stream card. The "B follows A" context the model learned no longer holds, and the blender that actually decides the screen knows nothing about how these items relate.

The paper puts this mismatch first and proposes generating the final list directly over the full cross-business candidate set of a request. Three things have to be solved for that. A request carries about a thousand candidates with different businesses and features, and they must be modeled together within online latency. Logged exposure sequences were produced by the old ranking policy, so imitating them does not reveal what users actually like. And ads are priced by GSP auction, so the generator must not break the existing auction rules.

The pipeline: one generator and two extra training signals

The data flow has four stages:

The key division of labor: the generator only models what the user will like, and the current bid enters only at serving time. During training, the logged historical eCPM goes only to a separate debiasing tower that the generator never sees. Details below.

How are a thousand candidates ranked together?

Candidates from all businesses go through the same MLP into one shared space. Besides item features, the input includes the business type and the scores and ranking signals produced by upstream retrieval and scoring. Ads and organic items become directly comparable while keeping track of where they came from.

Candidates then need to see each other, because whether an item deserves a slot depends on which other candidates the request offers. Full attention over a thousand candidates means about a million pairs, which is too slow online. UGR uses low-rank candidate attention: a learned projection matrix takes 8 differently weighted sums of the thousand candidates' keys to form 8 summary keys, and compresses the values into 8 the same way. Each summary is a weighted average over all candidates, with weights learned in training. Each candidate's query attends only to these 8 summaries, which still lets it see all of the request's roughly one thousand candidates indirectly. The work drops from about a million pairs to about eight thousand. This is computed once per request and reused by every decoding step and search path.

The decoding sequence opens with a few tokens for the user's recent session (the paper calls them session tokens), encoded from the current session's context features. In both training and online search, the decoder starts from these tokens. They play a different role from the request context token: session tokens sit in the decoding sequence, while the request context token is read only through cross-attention. Each chosen candidate's vector is then appended to the sequence. At each step, causal self-attention reads the prefix, cross-attention reads the request context token, which gives the decoder state for this slot; a projection specific to this slot then turns it into a scoring vector. Each candidate's score is the cosine similarity between that scoring vector and the candidate vector times a learned scale, followed by a softmax over the candidates not yet chosen. Candidate interactions are already computed, so each step only answers one question: given what is already on the screen, what goes next.

Why add WSFT and PermPO?

With NTP alone, the model learns how the old system ranked, not what users liked. UGR adds two objectives that share one feedback score: a click or a view longer than 3 seconds counts 1, and a purchase adds 2.

The first objective, called WSFT, multiplies each exposed item's NTP loss by this score. The logged sequence is unchanged; positions where users reacted are simply learned harder. In an illustrative record, shoe A was clicked, socks B were clicked and bought, and C and D got nothing. A scores 1, B scores 3, C and D score 0. NTP still gives each of the four slots a loss, and WSFT adds another weighted by 1, 3, 0, 0, so the step predicting B is learned hardest. C and D are not dropped, because NTP still covers them.

WSFT changes how much each step counts but never compares orderings. PermPO fills that gap. It reorders the same four exposed items and scores each ordering by DCG, using the feedback score as the gain. In the example, the logged order A, B, C, D gets about $1+3/1.585\approx 2.89$, and moving B to the top gives about $3+1/1.585\approx 3.63$. The B-first ordering beats the logged one and forms a preference pair.
$${\mathcal{L}}_{\mathrm{PermPO}}=-\log \sigma (\hat{s}(Y^{+})-\hat{s}(Y^{-}))$$
Here $\hat{s}(Y)$ is the generator's log-probability for the whole ordering, with each step's softmax taken over the generator's own logits and no debiasing-tower correction, so the preference signal acts directly on the generator used at serving, and $Y^{+}$ is the one with higher DCG. The intuition matches DPO: make the better ordering more likely than the worse one. Orderings with equal DCG are not paired, and requests with all-zero feedback add no loss. Preference pairs are built only from orderings of the same exposed items, so unexposed candidates are never placed into them; each step's probability is still a softmax over all candidates not yet chosen. The three losses are summed, with weight 1 for WSFT and 15 for PermPO.

Why split ad value between training and serving?

Online, the total score is the recommendation score plus $\alpha$ times the ad's eCPM. The recommendation score here is the scaled cosine similarity from before, the generator logit, not the probability after softmax. That total decides whether an ad wins and which slot it takes. The trouble is the training data. High-bid ads were exposed more often because of the old auction. A generator that fits exposures directly mistakes "this ad bid high" for "users like it" and bakes it into the recommendation score. Serving then adds eCPM again, and the bid is counted twice.

UGR adds a small tower during training. Its input is ad features plus the logged eCPM, and its output is a correction added to the ad's score; for non-ads the correction is zero. During training the correction is added to the generator logit before the softmax over legal candidates, and the model fits exposures with that distribution, so the bid-driven part of exposure is explained by the tower. The generator itself never sees eCPM or auction features. At serving time the tower is removed, and only the generator score plus current eCPM is used.

The figure shows the effect. Without the tower, the generator score correlates with eCPM at 0.195. With it, that correlation becomes −0.313, while the tower's correction correlates with eCPM at 0.727. The tower takes up most of the bid-related part. The generator score does not become independent of the bid, though; it turns negatively correlated, which the limitations section returns to.

Serving runs a multi-path search, in effect a beam search of width 4, on each step's total score, the generator logit plus $\alpha$ times current eCPM. At each step every kept prefix is extended with every legal candidate, a path's score is the sum of its step scores, all extensions are ranked together, and the top 4 are kept. After 4 steps there are four 4-item lists, and the existing downstream evaluator picks one for exposure. The paper states that ads keep the existing allocation and GSP pricing rules, but it does not say how, after the downstream evaluator picks the final list, the step-by-step ad competition in search maps to the final exposed slot and the actual GSP charge.

What the results show

Both offline datasets come from 30 consecutive days of Guess You Like logs, covering two scenarios with different user intent. Every sample carries the full upstream candidate set without truncation or sampling, so offline evaluation faces the same candidate scale as production. Scenario 1, where IPV means a click or a view over 3 seconds:

UGR is best on all six ranking metrics in both scenarios, and its IPV MAP is 7.53% above the strongest baseline. Yet UniRank has the highest Hitrate, the overlap with logged exposures. Ranking more like the old system does not mean ranking better by real feedback, which is exactly why WSFT and PermPO exist.

Removing PermPO drops IPV NDCG from 0.3666 to 0.3453, nearly back to NTP only, a larger drop than removing WSFT. Removing WSFT mostly hurts IPV NDCG and MAP, while both the IPV and CVR AUC are even slightly higher. Removing the tower lowers every metric, with CVR MAP falling from 0.4871 to 0.4716.

The most convincing evidence is the three-way online test. UGR and UGR-Single+Mix ran at the same time. UGR-Single+Mix is the same model ranking organic items only, followed by the existing blender. Each took at least 5% of traffic for over 14 days, with identical evaluator and ad constraints. Against the production baseline, Single+Mix raised transaction volume 2.84% and GMV 1.38%, while UGR reached 3.29% and 2.10%. The Single+Mix gains mean the model alone is already strong, so UGR's extra gain comes from folding blending into generation. Average latency rose only 12 ms; ad share of impressions fell 0.93% and ad spend rose 0.08%, both within guardrails.

Where I think it falls short

First, the lists are short. Each request yields four lists of four items, and the existing evaluator still picks one. With a four-slot prefix, the paper has no experiment on how slot-by-slot error and latency behave for longer screens or continuous scrolling.

Second, the full candidate set shows no clear offline gain by itself. When only organic candidates are truncated, keeping 30 to 200 of them stays within about 0.5% of the full 500 on IPV NDCG. In other words, within the tested range more organic candidates did not clearly lift the offline metric, and the extra value of unified generation shows up in the online comparison with Single+Mix. If blending causes little mismatch to begin with, there is less to gain.

Third, the tower may overcorrect. With it, the generator score turns negatively correlated with eCPM (−0.313), so high-bid ads get lower recommendation scores and rely on $\alpha$ times eCPM to make up the difference. Whether an ad wins then depends more on getting that single coefficient right. The 0.93% drop in ad share may be related.

How a recommendation team could try it

1. Measure the mismatch first. From logs, compare the reranker's output with the final blended list and see how much positions and neighbors change. If most requests barely change, unified generation will gain little.
2. Add PermPO to an existing generative reranker. It needs only feedback and permutations of exposed items, with no architecture change. In the paper's ablation, removing PermPO hurts all six ranking metrics more than removing WSFT does (there is no variant without NTP), so check whether offline NDCG rises clearly.
3. Where ads are blended, add the training-time debiasing tower. Before launch, plot generator score against eCPM levels comparing a generator trained with the tower (removed at serving) against one trained without it, and confirm the upward trend with eCPM is clearly weaker for the generator trained with the tower, then open a small slice of traffic.
4. Finally fold other businesses' candidates into the same generator and run the same three-way test as Single+Mix, to separate gains from the model and gains from unified blending.

Is it worth reading?

Once blending changes the list, the context the reranker learned is void. Many teams face this, and UGR offers a fix that ships under GSP rules, with a clean controlled comparison.