吴良超的学习笔记

Generative Recommendation (GR): What It Actually Replaces, and What It Doesn't

2026-07-12T05:00:00.000Z

“Generative Recommendation” has been one of the most frequently usedterms in recommender systems over the past year, but it actually refersto completely different things depending on who is speaking. A paperabout plugging LLMs into recommendation calls it “generativerecommendation”; a work using RQ-VAE to build semantic IDs also calls it“generative recommendation”; an industrial system that mergesrecall-ranking-reranking into a single encoder-decoder also calls it“generative recommendation”.

But these three things have essentially no intersection in theirengineering meaning.

When they are mixed together, two common but imprecise judgmentsappear:

One is “GR is just hype, industry can’t use it”
The other is “the cascade paradigm is about to be completelyoverturned”

Both judgments assume “GR” is one thing. But if you unpack itslightly, you find: semantic ID has been deployed in several companies,HSTU has been deployed at Meta, OneRec has been deployed at Kuaishou (atleast according to the papers), while most LLM-as-Recommender type worksstill have very little industrial deployment evidence. Clearly this isnot a 0/1 question of “is GR hype” that can be answered.

So what this article really wants to discuss is not “is GR thefuture”, but a more specific set of questions: After cascade (recall- coarse ranking - fine ranking - reranking) has supported industrialrecommender systems for over a decade, which assumption is GR actuallychallenging? What does it replace, and what does it not replace? Whathas been validated industrially, and what remains at the paperlevel?

To avoid the chapter-level details drowning out the main thread, letme state the full article’s thesis up front: GR is not awholesale replacement of cascade, but rather it opens a “use generativemodeling to re-frame” door for each layer of cascade. But the industrialdifficulty behind each door varies enormously; it must be examined layerby layer, not as a single thing.

ThreeImplicit Assumptions of the Cascade Paradigm

To understand what GR is challenging, we first need to unpack theimplicit assumptions of the cascade paradigm. The reason the cascadeparadigm works well is that at least three long-standing implicitassumptions hold behind it.

Assumption A: Items areDiscrete Atoms

In cascade systems, each item is represented by a hash ID +embedding, and semantic relationships between items are slowly learnedentirely through collaborative signals. This has worked for over adecade, but the preconditions are:

Behavioral signals are dense enough that each item can accumulatesufficient co-occurrence
Item vocabulary growth is controllable, the embedding table canhandle it
The long tail is unimportant, new items are a low fraction, orcold-start can be backed by side features

These three preconditions are actually starting to waver onlarge-scale, UGC-driven modern content platforms. The number of newitems added daily, the long-tail fraction, cross-domain transferneeds—all make the hash ID system increasingly strained.

AssumptionB: Each Step Can Be Scored Independently

This is exactly what the previous article 《PersonalizedRanking Formula: From Personalized Fine-Ranking to PersonalizedMixed-Ranking to Global Re-Ranking》 discussed: the first layer doespointwise $s(u,i,x)$, the secondlayer does mixed ranking, the third layer does listwise / Slate. Thisassumption actually contains two layers:

B1: Each item can be scored independently(pointwise) — given $(u,i)$, the model gives a single score, not depending on otheritems in the list
B2: Multi-step cascade approximates global optimum— recall, ranking, reranking are layered, assuming “sum of local optima≈ global optimum”

The reason this layering works is that cascade assumes localoptimum approximates global optimum.

But intra-list item-item interactions cannot be ignored — fatigue,complementarity, substitution, position dependence — this assumptionbreaks down. So listwise re-ranking, Generator-Evaluator, Slateoptimization are forced to graduate from “post-processing tools” to“first-class citizens”.

AssumptionC: Recommender Systems Do Not Exhibit a Significant Scaling Law

This is a fact that has long been unwilling to admit but alwaysaccepted: DLRM-style models have long been saturated in scalingalong the parameter dimension.

Meta’s 2022 UnderstandingScaling Laws for Recommendation Models (Ardalani et al.,arXiv:2208.08489) systematically quantified this for the first time— DLRM model quality in the data and compute dimensions still followsa power law + constant form, but parameter-dimension scaling hasalready gone “out of steam”, and continued parameter increasebrings rapidly diminishing marginal returns. The HSTU paper againdemonstrated the same phenomenon in its own baseline experiments: thequality-compute curve of traditional DLRM quickly enters a plateau,while HSTU’s curve continues to follow a power law over three orders ofmagnitude in compute.

This is also the fundamental reason recommender models have longremained at the hundred-million-parameter scale — not that bigger isn’twanted, but that bigger brings no gain. The subtle point: it’s not that“recommendation data isn’t enough”, but that “the expressiveness oftraditional DLRM architecture on large-scale behavior sequences islimited by its own design”.

What GR really challenges happens to be exactly these threeassumptions:

Assumption	Cascade Presupposition	How GR Challenges
A. Item is a discrete atom	hash ID + emb, no structure	semantic ID (RQ-VAE), hierarchical tokens
B. Each step can be scored independently	recall→rank→rerank cascade	HSTU challenges B1 (sequence modeling replaces pointwise); OneRecchallenges B2 (end-to-end generation of whole list)
C. No scaling law	DLRM bigger may not be better	HSTU validates power-law over three orders of compute

These three assumptions are not challenged simultaneously, and thecorresponding GR works are not the same kind. We will see that theindustrial evidence for semantic ID is fairly substantial; HSTUchallenges B1 and C with real deployment cases at Meta; while the publicindustrial evidence for “end-to-end generation of the whole list”(challenging B2) mainly comes from the Kuaishou OneRec technicallineage, with cross-company independent validation still limited. Thesethree things are not the same.

GR ReframesRecommendation as “Sequence Generation”

The core paradigm of GR can be roughly stated in one sentence:reframe recommendation from “scoring and sorting candidate items” to“generative prediction on user behavior sequences”.

But more rigorously, GR has at least two layers — broad andnarrow:

Broad GR: reframes recommendation from independent$(u,i)$ discriminative scoring tonext-action / sequential transduction on user behavior sequences. HSTUbelongs to this layer; it does not necessarily generate itemtokens.
Narrow GR: further lets the model autoregressivelygenerate item tokens / semantic IDs, then map back to real items. TIGERand OneRec belong to this layer.

Written in the narrow item-token generation form, it can be expressedas:

\[p(i_t \mid i_{

Symbol definitions:

$i_t$: the $t$-th item to be generated (i.e., “thenext content recommended”)
\(i_{: the user’shistorical interaction sequence (usually an item list sorted bytime)
$\text{tokenize}(\cdot)$: itemtokenizer, mapping a single item to several discrete tokens
$u$: user-side information (canbe user ID, profile, context, etc.)
$f_\theta$: autoregressivegenerative model or sequence prediction model (TIGER / OneRec directlygenerate item tokens; HSTU is closer to broad next-action sequenceprediction)

In plain terms, the traditional cascade view is:

“Give me a pile of candidate items, I’ll score each one and output asorted list.”

The narrow GR view is:

“Give me the user’s past behavior sequence, I directly generate thenext item (or the next segment of items).”

Broad GR and traditional cascade already differ in mathematical form;narrow GR differs even more in engineering implementation. The followingcomparison table is the backbone of the article:

Dimension	Discriminative Cascade	Generative Recommendation GR (typical form)
Item representation	hash ID + dense emb	semantic ID (narrow GR) / action token (broad GR)
Single decision object	score of single $(u, i)$	next action / token
List generation	recall → ranking → reranking cascade	autoregressive decode (can generate the whole segment at once)
Training objective	multi-objective weighted loss	next-token cross-entropy (+ subsequent reward alignment)
Scaling Law	empirically weak	HSTU validated at GPT-3-level compute
Inference form	matrix multiplication + ANN retrieval	autoregressive decode + beam search
Cold start	relies on side features	semantic ID carries semantic hierarchy

A boundary clarification is needed here to avoidbeing misled by the literal meaning:

GR ≠ “plugging LLMs into recommendation”. LLM-as-Recommender is onlyone form of GR; HSTU, trained from scratch on recommendation data, doesnot even depend on a general LLM
GR ≠ “end-to-end overthrow of cascade”. Even an end-to-end GR likeOneRec still retains business-level mixed ranking and constraintfallback mechanisms
GR ≠ “must use semantic ID”. Most of HSTU’s official implementationis still hash-based; it challenges assumptions B and C, not A

In other words, GR is a paradigm collection, not a singlearchitecture. The following three technical pillars correspondto three independent but mutually cooperating technical lines withinthis paradigm.

Three Key Questions

For GR to land industrially, it essentially needs to solve threethings, which exactly correspond to the three core components of the GRparadigm:

How to represent items as tokens that the model can generate?(Item Tokenization) — corresponds to the “itemrepresentation” component
What architecture to use for this sequence generation?(Generative Architecture) — corresponds to the“sequence modeling” component
How does the decoded token sequence correspond back to real items?(Decoding & Inference) — corresponds to the “tokenfall-back” component

Each of these has its own mature methods, representative works, anddeployment difficulty, must be examined separately, not mixedtogether to judge whether GR is mature. This is also whyearlier we said “semantic ID is already industrially deployed, HSTU isalready deployed, but end-to-end GR independent validation is stilllimited” — the maturity of the three components is completelydifferent.

Item Tokenization:Semantic ID and RQ-VAE

Core question: why can’t hash ID support GR?

The fundamental problem with hash IDs is that adjacent IDshave no semantic relationship. In discriminative cascade thisis fine — the embedding is looked up anyway, the ID itself is just aquery index, whether adjacent IDs look alike or not doesn’t matter.

But in the GR paradigm, what the model does is “generate IDs”. Thisrequires the ID space itself to have structure: similar items shouldhave similar IDs, so the model can infer from “has seen A” that“probably also likes B similar to A”. Hash IDs inherently lack thisproperty, so they must be replaced.

RQ-VAE Principle

Residual-Quantized VAE (RQ-VAE) is currently the most mainstream itemtokenizer in GR. The principle can be split into two steps.

Step 1: train a content encoder $E$

It takes the item’s content information (text description, image,behavioral statistics, category, etc.) and outputs a denseembedding:

\[z = E(i)\]

Step 2: residual-quantize $z$ into $L$ codebook indices

\[\begin{aligned}r_0 &= z \\c_l &= \arg\min_k \big\| r_{l-1} - e_k^{(l)} \big\| \quad l = 1,\dots, L \\r_l &= r_{l-1} - e_{c_l}^{(l)}\end{aligned}\]

Symbol definitions:

$r_l$: the residual vector atlayer $l$
$e_k^{(l)}$: the $k$-th vector in the $l$-th codebook (each codebook is alearnable vector dictionary)
$c_l$: the codebook index matchedat layer $l$
$L$: number of codebook layers,typically 3-4 in industrial implementations

Each item is finally represented as a token tuple $(c_1, c_2, \dots, c_L)$, called thisitem’s semantic ID.

The whole quantization process is a greedy process of “approximating$z$ layer by layer with codebooks”.Each step does the same thing: “how much of $z$ is not yet encoded? Find the closestcode in the current codebook to fill it in”. Unpacking it:

Initialization: $r_0 =z$, meaning “nothing encoded yet, the entire $z$ is to be encoded”.
Layer 1: pick a code $e_{c_1}^{(1)}$ from codebook 1 closest to$r_0$, $c_1 = \arg\min_k \|z - e_k^{(1)}\|$. Thencompute “the unencoded part”: $r_1 = z -e_{c_1}^{(1)}$.
Layer 2: layer 1 has “used up” the $e_{c_1}^{(1)}$ block, the remaining $r_1$ still needs to be approximated. Solayer 2 picks the code closest to $r_1$ from codebook 2: $c_2 = \arg\min_k \|r_1 - e_k^{(2)}\|$, newresidual $r_2 = r_1 -e_{c_2}^{(2)}$.
Layer $L$: andso on, each layer “takes over” the residual left by the previouslayer.

After walking through $L$ layers,summing all hit codes approximately restores $z$:

\[z \approx \sum_{l=1}^L e_{c_l}^{(l)}\]

That is, semantic ID $(c_1, \dots,c_L)$ is essentially a set of discrete indices, telling you “howto reassemble $z$ using vectors from$L$ codebooks”. The closerthe reconstruction is to $z$, themore semantic information the semantic ID preserves.

Here is a simple K=3, L=3 example:

$z = (1.0,\ 0.8)$
codebook 1 = $\{(1.0,\ 1.0),\ (-1.0,\0.0),\ (0.0,\ -1.0)\}$
codebook 2 = $\{(0.1,\ -0.1),\ (-0.1,\0.1),\ (0.2,\ 0.0)\}$
codebook 3 = $\{(0.05,\ -0.05),\ (-0.05,\0.0),\ (0.0,\ 0.05)\}$

The semantic ID construction is as follows:

Layer 1: $r_0 = (1.0,\0.8)$. Distances from the three candidate codes to $r_0$ are approximately $0.20,\ 2.15,\ 2.06$; the closest is thefirst, so $c_1 = 1$. Residual $r_1 = (1.0,\ 0.8) - (1.0,\ 1.0) = (0.0,\-0.2)$.
Layer 2: $r_1 = (0.0,\-0.2)$. Distances are approximately $0.14,\ 0.32,\ 0.28$; the closest is thefirst, so $c_2 = 1$. Residual $r_2 = (0.0,\ -0.2) - (0.1,\ -0.1) = (-0.1,\-0.1)$.
Layer 3: $r_2 = (-0.1,\-0.1)$. Distances are approximately $0.16,\ 0.11,\ 0.18$; the closest is thesecond, so $c_3 = 2$.

Final semantic ID is $(1,\ 1,\2)$. Reconstruction:

\[\hat{z} = (1.0,\ 1.0) + (0.1,\ -0.1) + (-0.05,\ 0.0) = (1.05,\ 0.9)\]

The reconstruction error from the true $z= (1.0,\ 0.8)$ is $\|z - \hat{z}\|\approx 0.11$ — the more layers and the larger the codebook, thecloser the reconstruction to $z$, andthe finer the information encoded in the semantic ID.

Several key points about this process:

Greedy quantization: each step only looks at “whichcode is closest in this layer”, without jointly considering subsequentlayer choices. In theory joint optimization gives more accuratereconstruction, but the combinatorial space is $K^L$, infeasible; the greedy scheme is notglobally optimal but training and inference are both $O(L \cdot K)$, which is the only thingaffordable in practice.
Quantization is lossy: each layer leaves a residual$\|r_l - e_{c_l}^{(l)}\|$. The larger$L$ and $K$, the more accurate thereconstruction, but the longer the token sequence and the slower thedecoding — this is the fundamental trade-off in RQ-VAE engineeringparameters.

In plain terms: it’s like classifying a book first by coarse category(“novel”), then within the coarse category by medium category (“mysterynovel”), then within the medium category by fine category (“locked-roommystery”). Each layer uses a small vocabulary to depict a specificgranularity of semantics. Semantically adjacent items will overlap onprefix tokens, and the model naturally learns the structure that“similar items have similar IDs”.

Why “residual + multi-layer” rather than one largecodebook

There is a natural question here: if you want $K^L$ different IDs, why not just use asingle codebook of size $K^L$ andquantize once?

The answer lies in structure and generalization. A single-layercodebook of size $K^L$ needs to learn$K^L$ independent vectors, each itemhits only one of them, and there is no relationship between adjacent IDs— this essentially degenerates back to hash ID.

RQ-VAE is different: each layer only learns $K$ vectors, with total parameter count$L \cdot K$, but through combinationyields $K^L$ semantic IDs. Moreimportantly, layer $l$ onlyencodes information not captured by the first $l-1$ layers — this is the full meaningof “residual”. And precisely because of this progressive structure,prefix tokens naturally carry coarse-grained semantics.

How to train

RQ-VAE is trained end-to-end with encoder + $L$ codebooks + decoder. Here the decoderreconstructs the item’s continuous representation $z$ (or the item feature representationcorresponding to $z$). The lossconsists of three parts:

\[\mathcal{L}_{\text{RQ-VAE}} = \underbrace{\|z -\hat{z}\|^2}_{\text{reconstruction}} + \underbrace{\sum_l\|\text{sg}(r_{l-1}) - e_{c_l}^{(l)}\|^2}_{\text{codebook learning}} +\underbrace{\beta \sum_l \|r_{l-1} -\text{sg}(e_{c_l}^{(l)})\|^2}_{\text{commitment}}\]

$\hat{z}$: the itemrepresentation reconstructed by the decoder using the quantized $\sum_l e_{c_l}^{(l)}$
$\text{sg}(\cdot)$:stop-gradient, blocking gradient backpropagation
$\beta$: commitment weight,VQ-VAE default 0.25

Plain explanation:

Reconstruction loss makes the whole codebookcombination able to restore the item representation
Codebook learning loss makes each codebook vectorslowly approach the mean of residuals that actually hit it
Commitment loss conversely constrains the encoderoutput not to drift too far from the codebook

The quantization operation $\arg\min$ is discrete andnon-differentiable, solved in engineering by thestraight-through estimator (STE): forward pass uses thequantized value, backward pass lets gradients directly bypass thequantizer to reach the encoder. This is a standard trick inherited fromVQ-VAE.

Where do the codebook vectors come from

The $L$ codebooks are notpre-defined dictionaries, but trainable parameters learnedend-to-end together with the encoder / decoder. Thelearning process of each codebook is intuitively equivalent toK-means clustering in residual space — the $K$ codes slowly evolve into “the clustercenters of $K$ common residuals”.Concretely, the $\sum_l \|\text{sg}(r_l) -e_{c_l}^{(l)}\|^2$ term in the loss above can directly dogradient updates, or EMA can maintain the code as “the mean of allresiduals that hit it over a recent period” (the VQ-VAE paper recommendsthe latter as more stable).

After training, the codebook is generally frozen,and all items are quantized using this fixed codebook. But industrially,note that as item distribution drifts and new categories appear, thequantization quality of the original codebook gradually degrades —periodic retraining of RQ-VAE at weekly / monthly scale is needed, andafter retraining, the semantic IDs of all items must be globallyrecomputed. This is an engineering cost that cannot be ignored.

Common values for engineering parameters

In industrial deployment there are several relatively convergedempirical values:

Parameter	Common value	Note
Codebook size $K$	256 (or 512)	Too small = insufficient expressiveness; too large = prone tocollapse
Number of layers $L$	3-4	TIGER uses 4 layers
Effective vocabulary $K^L$	$\sim 10^9$ order	Enough to cover ten-billion-scale item pools
Commitment weight $\beta$	0.25	VQ-VAE default
Codebook vector dimension	32-128	Determined by content encoder output dimension

That is, a typical configuration ($K=256,L=4$) yields about 4.3 billion different semantic IDs, farexceeding the item scale of typical recommender systems.

The biggest pitfall in industrial deployment: codebookcollapse

This is the most common problem in actual RQ-VAE deployment and theleast discussed in papers.

Symptom: after several training rounds, a few codebook vectors getrepeatedly hit, while others are almost never used. For example, of256 codes, only 30 are actually active. This is equivalent to cuttingthe effective vocabulary from $K^L$to $30^L$, with expressivenessdropping sharply, and the hierarchical structure of semantic IDs alsocollapses.

Root cause: $\arg\min$ iswinner-take-all. Once a code is hit more in the early stage, its updatedirection shifts toward the average vector of items that hit it, andnext round it’s more likely to be hit again, forming positivefeedback.

Common mitigation methods:

Codebook reset: periodically replace long-unusedcodes with “the hardest-to-explain residual vectors” (reservoirsampling)
EMA update: use exponential moving average tosmooth codebook learning, avoiding being dominated by a few batches
K-means initialization: initialize the codebookwith K-means centers of training-set residuals, avoiding cold-startbias
Entropy regularization: add a term to the lossencouraging the entropy of the code hit distribution

These methods are mentioned in the original RQ-VAE paper andfollow-up works, but the actual ratio and trigger conditions highlydepend on the specific business’s item distribution, often requiringrepeated tuning online.

Representative Work: TIGER

TIGER (Rajput et al.,NeurIPS 2023, arXiv:2305.05065) is the earliest and mostrepresentative work in this paradigm. It does three things:

Use RQ-VAE to generate a semantic ID for each item
Use a T5-style autoregressive transformer to learn “given ahistorical behavior sequence, generate the next item’s semantic ID”
At inference, use beam search to generate candidate semantic IDs,then map back to real items

TIGER’s real paradigm-level contribution, not some specific number,is that it proved one thing:

Transformer memory itself can serve as a semantic index — noseparate ANN index is needed; the model parameters themselves take onthe recall task.

This is almost unimaginable under the traditional cascade view: therecall side has been the “embedding + ANN” paradigm for over a decade,and TIGER first replaced it wholesale with “generative decoding”.

TIGER’s engineering details are as follows:

Content encoder: sentence-T5, encoding item text descriptions into768-dim vectors
Then projected to 32-dim space for RQ
$K = 256$, $L = 4$
To avoid different items being quantized to exactly the samesemantic ID (hash collision), TIGER adds an additional disambiguatingtoken to each ID tuple (effectively becoming 5 tokens)

The last detail is actually quite important: even with an effectivevocabulary of $K^L \approx 4 \times10^9$, different items will still be quantized to the same ID,requiring extra tokens to distinguish. This is also why in the papermany semantic IDs are actually 4-5 tokens rather than a clean 4 — such“patches” are the norm in industrial implementation.

Limitations

Semantic ID is not a panacea; several of its engineering boundariesneed to be seen clearly:

Trade-off between vocabulary size andexpressiveness: the number of codebook layers $L$ and per-layer size $K$ determine the effective vocabulary$K^L$. Too small $L$ = insufficient expressiveness; toolarge $L$ = token sequence too long,decode slow
Strong dependence on content encoder quality: itemswith weak behavioral signals and weak content signals (e.g., pureID-type short content) still cold-start
Codebook drift: after the model goes online, how toassign semantic IDs to new items? Whether to periodically retrain thecodebook? These are pits not discussed in papers but inevitablyencountered industrially

Finally, RQ-VAE was not invented by GR; it has been mature in images(VQ-VAE) and speech for years. The problem it solves — “discrete itemshave no structure” — is the prerequisite for the TIGER / OneRec“generate item token” line to hold. The scaling law of the HSTU line isrelatively orthogonal to semantic ID; but for routes that need toautoregressively generate items, without semantic ID, subsequentconstrained decoding, transformer-as-index, and end-to-end slategeneration are all hard to establish. In addition, even if a teamdoesn’t plan to switch to full GR, first injecting semantic ID as aside feature into the existing cascade can already yield cold-start andlong-tail gains.

Three Routes ofGenerative Architecture

The “architecture” pillar of GR is currently clearly divided intothree routes. They are all formally called “generative”, but they solvefundamentally different problems, and their deployability differsenormously. Below they are introduced in descending order ofindustrial deployability.

Route1: Training a Generative Foundation Model on Recommendation Data

The representative work is Meta HSTU (arXiv:2402.17152,“Actions Speak Louder than Words”). The main thing it does: reframethe DLRM-era “sparse features + multi-tower scoring” into “sequencemodeling on user behavior sequences”, then use a transformer variantcustomized for recommendation scenarios to scale it up.

First clarify an easily misunderstood point: “generative” in HSTUdoes not mean it generates natural language like an LLM, nor does itmean it must generate RQ-VAE semantic IDs. What it does is a deeperreframing: treats user historical behavior as a string of actiontokens, and the model predicts future actions based on past actionsequences. Here the action can include item ID, action type,timestamp, scenario, device, context features, and otherhigh-cardinality sparse information.

That is, the input of a traditional DLRM/ranker is more like a“feature table for the current request”:

\[s(u, i, x) = f_\theta(\text{user features}, \text{item features},\text{context})\]

HSTU’s input is more like a behavior stream unfolded over time:

\[x_t = \mathrm{Embed}(i_t, a_t, c_t, \Delta t_t, \dots)\]

Symbol definitions:

$i_t$: the item of the $t$-th interaction
$a_t$: interaction action, e.g.,impression, click, completion, like, purchase
$c_t$: the context at the time,e.g., entry, device, region, scenario
$\Delta t_t$: time interval ortime position feature
$x_t$: the $t$-th action representation after fusingthese sparse features

The training objective also changes. A traditional ranker morecommonly “scores the current candidate item”; HSTU is:

\[p(x_{t+1} \mid x_{\le t}) = f_\theta(x_1, x_2, \dots, x_t)\]

In plain terms, it’s not just asking “will this user click this itemnow”, but asking “given this user’s path so far, what action ismost likely to happen next”. This is where HSTU is closer togenerative modeling than a traditional pointwise ranker.

Under this framework, HSTU makes three key changes relative to thestandard Transformer. The key to understanding these changes:each change corresponds to a “standard Transformer mismatch inrecommendation scenarios” — HSTU didn’t change things for thesake of changing them, but because default assumptions reasonable in NLPbecome obstacles in recommendation scenarios. The three changes beloware examined in descending order of importance.

Change1: Training Objective from “Per-Sample Scoring” to “Behavior SequenceTransduction”

The training paradigm of a traditional ranker

The traditional ranker’s training paradigm is “per-sample scoring”:each $(u, i, \text{label})$ sampleindependently contributes a binary classification loss (click /no-click). The underlying assumption is “each sample is independent, theobjective can be decomposed into per-sample accumulation”.

HSTU changes to “sequence transduction”

“Sequential Transducers” in the HSTU paper title hints at a morefundamental shift: the training objective changes from“per-sample classification” to “sequence transduction”.Transducer means: given a historical behavior sequence, output thedistribution over future behaviors or target actions — not just servinga single binary CTR objective, but unifying multiple recommendationtasks (click, completion, like, conversion, …) into a prediction problemon the sequence.

Seeing the difference through a concrete example

This difference is most easily masked by the surface similarity of“both use CE loss”, so let’s use a concrete example. Suppose the onlinelog has the following user behavior:

User U in a certain session did 4 actions in sequence: 1. Watchedbasketball video A, completed 2. Watched basketball video B, liked 3.Watched food video C, skipped 4. Watched basketball video D,completed

Pointwise ranker’s approach — splits this sessioninto 4 independent samples:

Sample	User	Item	Label
1	U	Basketball A	1 (completed)
2	U	Basketball B	1 (liked)
3	U	Food C	0 (skipped)
4	U	Basketball D	1 (completed)

These 4 samples can be shuffled in a batch — they are completelyequivalent in status to a sample like “user V skipped game E”. Eachsample independently computes a binary CE, and they sum to the batchloss:

\[\mathcal{L}_{\text{pointwise}} = -\big[\log \sigma(s(U, A)) + \log\sigma(s(U, B)) + \log(1 - \sigma(s(U, C))) + \log \sigma(s(U, D))\big]\]

The history sequence (if used) only enters as a feature into $s(U, \cdot)$ and does not participate inloss construction.

HSTU’s approach — treats the entire session as onetraining sample, no splitting. Each position contributes a “predict nextstep” loss term:

Position $t$	Input	Predict target	Loss term
1	$x_1$ (watch basketball Acomplete)	$x_2$ (watch basketball Blike)	$-\log p(x_2 \mid x_1)$
2	$x_1, x_2$	$x_3$ (watch food C skip)	$-\log p(x_3 \mid x_1, x_2)$
3	$x_1, x_2, x_3$	$x_4$ (watch basketball Dcomplete)	$-\log p(x_4 \mid x_1, x_2,x_3)$

\[\mathcal{L}_{\text{HSTU}} = -\big[\log p(x_2 \mid x_1) + \log p(x_3 \midx_1, x_2) + \log p(x_4 \mid x_1, x_2, x_3)\big]\]

A sequence of length $T$contributes $T-1$ loss terms, eachposition being a multi-class classification task of “given the first$t$ steps of history, predict the$t+1$-th step”.

Three differences between the two methods:

Dimension	Pointwise ranker	HSTU
Can samples be shuffled	Yes, session split into independent samples	No, order is part of the loss
Loss form	binary CE accumulated per-sample	multi-class CE at each position
How many loss terms per session	$T$ (one per $(u,i)$)	$T-1$ (predict next at eachposition)
What the model predicts	score $(u, i)$	predict next action
Are items independent	Yes	Influence each other via attention

An extreme case showing the difference: suppose user U’s session is“watch basketball A → watch basketball A → watch basketball A → watchbasketball A” (watch the same video 4 times in a row).

Pointwise ranker: sees 4 identical samples $(U, A, 1)$. The model only learns the fact“user U likes basketball A”, and the 4-fold repeated signal iscompressed into “interest strength in A”
HSTU: sees a sequence $(x_1, x_2, x_3, x_4)$ all “watchbasketball A”. The loss at each position asks “after watching A, what’snext” — the model learns the sequential dependency “after watching A,the user watches A again”, not just the static preference “user likesA”

This characteristic of “repetition itself is a signal” cannot becaptured by pointwise loss at all, but HSTU’s next-action loss naturallycaptures it — this is also why HSTU has more advantage over pointwiserankers in long-history behavior modeling.

Two engineering usages

In engineering, this unified paradigm can land in two usages:

Candidate scoring: given user history and candidateitems, treat candidate items as part of future actions, predicting theirprobability or value — this is HSTU’s usage replacing the traditionalfine-ranking
Recall-side user encoding: use HSTU to encode userhistory into a strong user state vector $A_t$, then project it into a queryembedding and feed it to ANN index for retrieval — this is HSTU’s usagereplacing the traditional two-tower recall

A point that needs clarification here: HSTU on the recall sidedoes not “generate item tokens”. It only replaces the user-sideencoder in the two-tower model — the item side is still hash ID +embedding + ANN index. Real “generative recall” (autoregressivelygenerating item token sequences) is the TIGER / OneRec path, requiringsemantic ID, which HSTU’s official implementation does not take. This isalso why “Generative” in the HSTU paper title refers to sequencemodeling (reframing recommendation as next-action prediction),not to output form (generating item tokens) — these twothings are bundled together in TIGER/OneRec, but separated in HSTU.

So HSTU can be described both as a generative recommender and usedwithin ranking / recall systems. What it really replaces is not somemodule name, but the “score each sample independently” modelingassumption — reframing recommendation from a “discriminative problem” toa “sequence prediction problem”.

HSTU output layer structure illustration

The figure below summarizes how the HSTU output layer works intraining and inference scenarios:

A key point to emphasize: HSTU’s output layer is not anindependent $W_{output}$ matrix likein LLMs, but a “two-tower dot product” structure — user state $A_t$ and item embedding are dot-productedto get the score, and the item embedding table is shared between theinput side (encoding history sequence) and the output side (scoring),with the same parameters. This is consistent with the scoring method oftraditional two-tower recall models.

Similarity with traditional recall models

Speaking of this, you’ll find an interesting similarity: HSTU’straining paradigm is very similar to the traditional two-tower recallmodel — both do user embedding and item embedding dot product, bothtrain with sampled softmax (positive + sampled negatives). Classicrecall models like DSSM, YoutubeDNN, MIND all follow this pattern, andHSTU inherits this paradigm at the output layer and loss level.

The real difference is in the user encoder: traditional two-towerpools user historical behavior into a vector (mean/sum) or shallow MLP,while HSTU uses a sequence model to explicitly model dependenciesbetween behaviors. So a more accurate statement is:

HSTU ≈ upgrades the two-tower recall’s user encoder from“pooling/shallow network” to “sequence model”, but retains the two-towerrecall paradigm in training loss (sampled softmax) and scoring (dotproduct).

This also explains why HSTU can land in both fine-ranking and recallscenarios — its output layer structure is inherently two-tower dotproduct, naturally compatible with recall’s scoring method; and the userstate quality improvement brought by sequence modeling lets it replacetraditional fine-ranking. One model, two usages, behind which is thesame training and scoring paradigm.

Change 2:Pointwise SiLU Replaces Softmax Attention

Motivation and attention basics

This change looks like just swapping an activation function, but whatit really changes is the semantics of attention: standard softmaxattention outputs “weighted average”, HSTU’s pointwise SiLU outputs“evidence accumulation”.

First explain what attention is doing. One-sentence summary:the position to be predicted emits a query $Q$, going into history to find relevantinformation; each behavior in history has a “label” $K$ and a “content” $V$ (the information this behaviorcarries). $Q$ dot-productswith some $K$ to get a “relevancescore” — the larger the score, the more relevant this historical item isto the current query. Then aggregate all $V$ by relevance scores to get attention’soutput.

To get the numbers clear, we simplify vectors to 1-dim scalars (realmodels use multi-dim vectors, but 1-dim suffices to illustrate).

Suppose we want to predict “the user’s interest in the nextbasketball video”, so the query $Q$is “basketball direction”. There are two types of videos in history:

Historical behavior	Type	$K$ (label)	$V$ (content)	Relevance score $s = Q \cdotK$
1st	Basketball	1.0	1.0	1.0
2nd	Basketball	1.0	1.0	1.0
3rd	Basketball	1.0	1.0	1.0
4th	Food	0.1	0.2	0.1

That is, basketball videos all have relevance score 1.0 (stronglyrelevant), the food video’s relevance score is 0.1 (weaklyrelevant).

Now compare three users: user A has only 1 basketball history, user Bis the table above (3 basketball + 1 food), user C has 100 basketballhistories.

How softmax attention computes

Standard Transformer attention: first $\exp$ each relevance score, then normalizeinto “weights summing to 1”, then use these weights to do weightedaverage over $V$. The formula:

\[A = \sum_j \mathrm{softmax}(s_j) \cdot V_j,\quad \mathrm{softmax}(s_j) =\frac{e^{s_j}}{\sum_k e^{s_k}}\]

User A (1 basketball):

Scores: $[1.0]$
Normalized weights: $[1.0]$ (onlyone position, weight naturally 1)
Output: $1.0 \times 1.0 =\mathbf{1.0}$

User B (3 basketball + 1 food):

Scores: $[1.0, 1.0, 1.0,0.1]$
After $\exp$: $[2.72, 2.72, 2.72, 1.11]$
Sum: $2.72 \times 3 + 1.11 =9.27$
Normalized weights: $[0.294, 0.294,0.294, 0.120]$
Output: $0.294 \times 1.0 + 0.294 \times1.0 + 0.294 \times 1.0 + 0.120 \times 0.2 = 0.882 + 0.024 =\mathbf{0.906}$

Note what happens here: user B watched 2 more basketball videos thanA, but the output actually drops from 1.0 to 0.906 — because the 3 newbasketball videos have to compete for the same fixed weightbudget of 1 with that food video, each basketball gets only0.294, dragging the total weight down.

User C (100 basketball):

All scores 1.0
Normalized weights: each $1/100$
Output: $100 \times (1/100) \times 1.0 =\mathbf{1.0}$

Putting the three results side by side:

User	History	Softmax output
A	1 basketball	1.0
B	3 basketball + 1 food	0.906
C	100 basketball	1.0

The problem immediately surfaces: user A watched only 1 basketball,user C watched 100 — the interest strength clearly differs by 100×, butsoftmax gives almost identical outputs. Softmax can only express“what is the interest direction”, not “how strong is the interest”.The reason is the normalization: all weights are forced to sum to 1;whether there’s 1 or 1000 historical items, the total attention budgetis fixed.

How pointwise SiLU attention computes

HSTU’s approach: don’t normalize; let each historical itemindependently contribute a piece of evidence, then just sumthem. The formula:

\[A_i = \sum_{j \le i} \mathrm{SiLU}(s_j) \cdot V_j,\quad \mathrm{SiLU}(x)= x \cdot \sigma(x) = \frac{x}{1 + e^{-x}}\]

Here $\mathrm{SiLU}$ (also calledswish) is an activation function whose shape is: larger input $x$ → larger output; when input is small ornegative, output approaches 0. It replaces softmax’s normalization butretains the role of “non-linear transformation on relevance scores”.

First compute two SiLU values we’ll need:

$\mathrm{SiLU}(1.0) = 1.0 \times\sigma(1.0) = 1.0 \times 0.731 = 0.731$
$\mathrm{SiLU}(0.1) = 0.1 \times\sigma(0.1) = 0.1 \times 0.525 = 0.0525$

User A (1 basketball):

Output: $\mathrm{SiLU}(1.0) \times 1.0 =0.731 \times 1.0 = \mathbf{0.73}$

User B (3 basketball + 1 food):

Basketball contribution: $3 \times\mathrm{SiLU}(1.0) \times 1.0 = 3 \times 0.731 = 2.193$
Food contribution: $\mathrm{SiLU}(0.1)\times 0.2 = 0.0525 \times 0.2 = 0.0105$
Output: $2.193 + 0.0105 =\mathbf{2.20}$

User C (100 basketball):

Output: $100 \times \mathrm{SiLU}(1.0)\times 1.0 = 100 \times 0.731 = \mathbf{73.1}$

Three results side by side:

User	History	Softmax output	SiLU output
A	1 basketball	1.0	0.73
B	3 basketball + 1 food	0.906	2.20
C	100 basketball	1.0	73.1

The difference is clear:

Under softmax, users A and C have almost identicaloutputs (1.0 vs 1.0), no strength difference visible
Under SiLU, user C’s output is 100× user A’s (73.1vs 0.73), directly reflecting the interest strength difference between“watched 100” and “watched 1”

This exactly corresponds to the signal recommendation cares mostabout — “how interested the user is in basketball” is itselfhidden in the absolute count of “how manyinteractions”.

Restoring to the multi-dim vector form in realmodels

The above example simplified vectors to 1-dim scalars so you canfollow along. In real models $Q, K,V$ are multi-dim vectors, but the core logic is exactly thesame. Let me first clarify a few transformer basics that are easilyoverlooked, so the formulas below are understandable.

First, $Q, K, V$ are not directlytrained parameters, but intermediate results after projection of theinput. HSTU’s input at step $t$ is anevent vector $x_t = \mathrm{Embed}(i_t, a_t,c_t, \Delta t_t, \dots)$ — it describes “what item the userinteracted with at step $t$, whataction, in what scenario, how long since last”. Then three sharedtrainable weight matrices $W_Q, W_K,W_V$ project $x_t$ into threeroles:

\[q_t = W_q \tilde{x}_t,\quad k_t = W_k \tilde{x}_t,\quad v_t = W_v\tilde{x}_t\]

All positions in the sequence share the same $W_Q, W_K, W_V$ — the difference is only inthe input $x_t$ (basketball event vsfood event), so the projected $K$differs. The basketball video’s $K=1.0$ and food video’s $K=0.1$ in the example can be understood as“the learned $W_K$ projects these twoevent types to different label positions”.

Second, what attention really does is aggregate historical eventsinto “user state”. HSTU at step $t$uses attention to aggregate $x_1, \dots,x_t$ into a hidden state $A_t$ — this is “the user’s state afterexperiencing $t$ steps of behavior”,while $x_t$ itself is just the eventat step $t$. The wholesequence modeling is the cycle of “based on $x_1, \dots, x_t$ compute state $A_t$, then based on $A_t$ predict what behavior is most likelyat step $t+1$”.

With these two points understood, the difference between the twoformulas becomes clear. Standard Transformer attention:

\[A_i = \sum_{j \le i} \mathrm{softmax}(q_i^\top k_j) \cdot v_j,\quad\sum_j \alpha_{ij} = 1\]

HSTU’s pointwise normalized-less attention:

\[A_i = \sum_{j \le i} \phi(q_i^\top k_j + b_{ij}) \cdot v_j,\quad \phi =\mathrm{SiLU}\]

Symbol definitions:

$q_i, k_j, v_j$: query / key /value vectors, from positions $i$ and$j$ respectively (obtained by $W_Q, W_K, W_V$ projection above)
$b_{ij}$: optional position /time / relative order bias, expressing the relationship between “howlong ago a behavior happened” and “the current behavior”
$\phi$: activation function. HSTUuses SiLU (also called swish), no softmax normalization
$A_i$: the hidden stateaggregated from historical behavior at position $i$
$j \le i$: causal mask, onlyallows the current position to see the past, not peek at the future

The two formulas differ only by a softmax, but their semantics arecompletely different: softmax outputs “weighted average”, SiLUoutputs “evidence accumulation”. A rough analogy summarizes thedifference:

softmax attention is like asking: “Of these 100 historical items,which are most important? Distribute the total weight of 1 amongthem.”
pointwise SiLU attention is like asking: “How much evidence can eachhistorical item provide? Add the useful ones, add less or none for theuseless ones.”

Why is this especially important for recommendation but not so muchfor NLP? This can actually be reverse-inferred from the preconditionunder which softmax normalization holds in NLP. Softmax normalizesweights to 1, essentially assuming “historical positions are incompetition” — tokens in a sentence explain each other within a limitedcontext, “which token is more important” is a reasonable question, andnormalization lets the model focus on the most relevant few. Butrecommendation behavior sequences are completely different — repeatcounts, continuous interactions, and interest strength themselves arefeatures; behaviors shouldn’t compete for the same attention budget.HSTU switching to pointwise SiLU essentially acknowledges “inrecommendation scenarios, the weighted average semantics reasonable inNLP is actually wrong, and should be replaced by evidence accumulation”.The HSTU paper observed on synthetic data that this difference can bringup to 44.7% NDCG gap.

Change3: Retaining Hash / Sparse System, Not Strongly Dependent on SemanticID

This point is exactly what was mentioned in change 1, and is also apoint very easily misunderstood.

The TIGER / OneRec generative route is highly dependent on semanticID — because they want to “generate items”, they must first turn itemsinto generatable token sequences. A common misunderstanding is “sinceHSTU is a generative recommender, it should also depend on semantic ID”.But HSTU’s official implementation is exactly the opposite,mostly still using hash ID + sparse feature embedding.

Why can HSTU not depend on semantic ID?

Because HSTU challenges the parts of cascade’s assumptions B and Cthat it actually solves, not all of them. Specifically:

Challenges B1 (pointwise independent scoring): HSTUuses sequence modeling to replace pointwise scoring — training objectivechanges from “per-sample classification” to “sequence transduction”,items are implicitly modeled through the history sequence, no longerisolated $(u, i)$ scoring
Challenges C (no scaling law): HSTU uses pointwiseSiLU attention + sequence transduction training objective + supportingengineering optimizations, making the recommender model follow power-lawscaling over three orders of magnitude in compute, validating therecommender scaling law systematically for the first time
Does not challenge A (item is discrete atom): inHSTU’s official implementation, items are still hash ID + sparseembedding, not replaced by semantic ID
Does not challenge B2 (multi-step cascade approximatesglobal optimum): HSTU still lands in the cascade system asfine-ranking or recall, not merging recall/ranking/reranking into oneend-to-end model

The last point is easily misunderstood. “Generative” in the HSTUpaper title refers to generative in modeling approach(reframing recommendation as next-action prediction), notgenerative in output form (autoregressively generatingitem tokens). The former is what HSTU does — using sequence modeling toreplace independent scoring; the latter is what TIGER / OneRec do —decoding semantic ID token sequences and mapping back to real items.HSTU’s official implementation does not generate item tokens, so itstill depends on ANN retrieval and still lands in the cascadesystem.

What really challenges B2 (end-to-end replacement of cascade)is OneRec — it uses an encoder-decoder to generate the wholelist in one go, unifying recall + ranking + slate in one generativeframework. This point will be clearer in the later “GR’s landing formsacross cascade layers” comparison table: HSTU is in “first-layerfine-ranking”, OneRec is in “end-to-end”.

So the core of HSTU is “scalable sequence modeling on behaviorsequences”, not “redesigning item representation”. Hash ID in HSTU isjust one kind of action token — as long as behavior sequence modeling isstrong enough, the model itself learns relationships between items, noneed to switch to semantic ID.

HSTU and semantic ID are orthogonal

So HSTU and semantic ID are two orthogonal things:

If the business’s main bottleneck is cold-start, long-tail,unstructured item representation, semantic ID is more direct —it gives new items a structured position
If the business’s main bottleneck is behavior sequencemodeling capability and model scaling, HSTU is more direct — itsolves backbone capability, not item representation
If both hold, in theory semantic ID can be fed to HSTU as part ofitem representation, but this is just icing on the cake, not aprerequisite for HSTU to hold

This point matters for actual deployment: no need to finish semanticID before trying HSTU; the two can proceed independently.

Route 2:End-to-End Generative (OneRec / TIGER Family)

Route 1 is “train backbone on recommendation data but don’t generateitem tokens” — HSTU lands in fine-ranking/recall, still a module in thecascade system. Route 2 is more radical: train anencoder-decoder from scratch on recommendation data, autoregressivelygenerate item tokens (semantic IDs), unifying recall + ranking + slatein one generative framework, aiming to end-to-end replacecascade.

Representative works are OneRec (arXiv:2502.18965)and TIGER(arXiv:2305.05065). The two have similar architectural ideas, butvery different deployment maturity — TIGER stopped at academicvalidation, OneRec has been deployed at scale on Kuaishou’s main app(full deployment data in OneRec Technical Report,arXiv:2506.13695).

OneRec’s core changes are as follows:

Encoder-decoder structure: encoder processes userhistory sequence, decoder autoregressively generates the next (or nextgroup of) item’s semantic ID tokens
Session-wise list generation: not predicting itemby item, but generating the whole session’s item list at once, lettingthe model learn the relative relationships and ordering among items
Strong dependence on semantic ID: because it needsto “generate items”, it must first represent items as generatable tokensequences (RQ-VAE semantic ID) — this contrasts with HSTU’s “no strongdependence on semantic ID”
MoE parameter scaling: OneRec’s decoder FFN usesMoE, letting the model scale from 0.015B to 2.633B parameters whilestill following the scaling law

The figure below shows the core flow of end-to-end generativerecommendation like OneRec:

It’s divided into five steps (engineering details deferred to thelater “Decoding & Inference” section):

item → semantic ID (offline, one-time): each itemis encoded into a semantic ID token sequence via RQ-VAE, similar itemsshare prefixes. This step is the foundation for efficient path pruningin subsequent constrained decoding
User history → encoder hidden state (online, once perrequest): user history sequence (each historical item alsorepresented by semantic ID) is fed into the encoder to get hidden state$H$. This step is the same as Route 1HSTU encoding user state; the difference is the next step — HSTU uses$H$ to score candidates, OneRec uses$H$ to drive the decoder
Decoder autoregressively generates semantic ID(session-wise): based on $H$, starting with [BOS], thedecoder autoregressively generates a complete session (5-10 items) ofsemantic ID sequences. This is the key difference between Route 2 andRoute 1 — HSTU’s candidates are given by upstream and it only scores;OneRec generates the whole list itself
Constrained decoding ensures validity: thedecoder’s raw generated token sequence may not correspond to any realitem; engineering uses Trie-based constrained decoding to ensure onlyvalid semantic IDs are generated
semantic ID → real item: valid semantic IDs arelooked up back to real items via a mapping table, forming the finalrecommendation list in generation order

Training objective

Route 2’s training objective is next-token CE loss, corresponding to“given history and generated tokens, predict the next semantic IDtoken”:

\[\mathcal{L}_{\text{NTP}} = -\sum_{i=1}^{m} \sum_{j=0}^{L-1} \logP(c^{(j)}_i \mid [\text{BOS}], c^{(1)}_1, \dots, c^{(j-1)}_i; \Theta)\]

Where $m$ is the number of itemsin a session, $L$ is the semantic IDlayer count per item, $c^{(j)}_i$ isthe $j$-th codebook index of the$i$-th item. The generationprobability of the whole session can be decomposed as (TIGER’sformula):

\[P(\text{session} \mid \text{history}) = \prod_{i=1}^{m}\prod_{j=0}^{L-1} P(c^{(j)}_i \mid c^{(

The alignment stage (IPA) does not only optimize DPO loss, but addsNTP loss and DPO loss weighted as a joint training objective (see thelater “Training Objective: From next-token to preference alignment”section):

\[\mathcal{L} = \mathcal{L}_{\text{NTP}} + \lambda\mathcal{L}_{\text{DPO}}\]

What’s most unique about Route 2 is not “generating items” itself(TIGER also generates items), but session-wise listgeneration — generating the whole session at once rather thanone item at a time. This brings two benefits:

Modeling relative relationships and order amongitems: traditional pointwise/next-item prediction can only ask“what is the next item”; session-wise can ask “what should this wholescreen recommend, and in what order”, letting the model learn intra-listdependencies itself (e.g., recommending sports peripherals after abasketball video is more reasonable than recommending food)
Naturally unifying recall + ranking + slate: thetraditional cascade’s three steps “recall pulls candidates →fine-ranking scores → reranking produces slate” are compressed into onestep “decoder generates the whole slate at once” in session-wisegeneration. This is the fundamental reason Route 2 can challengeassumption B2 (multi-step cascade approximates global optimum) — itdirectly replaces multi-step cascade with one-step generation

The latency challenge of autoregressively decoding the whole list isvery severe — beam search, constrained decoding, KV cache, MoE sparseactivation and other engineering optimizations are key to OneRec’sdeployment. These engineering details are deferred to the later“Decoding & Inference” section, which will use OneRec as a concreteexample to tie together constrained decoding, beam search, industriallatency constraints and other general mechanisms.

Route 1 and Route 2 both train from scratch on recommendation data,but their “output form” is completely different:

Dimension	Route 1 (HSTU)	Route 2 (OneRec)
Generates item tokens	No (two-tower dot-product scoring)	Yes (autoregressively generates semantic ID)
Depends on semantic ID	Not strongly (hash ID works too)	Strongly (must generate tokens first)
Which cascade layer it lands in	Fine-ranking / recall (replaces one layer)	End-to-end (unifies recall + ranking + slate)
Challenged cascade assumptions	B1 (pointwise independent scoring) + C (scaling law)	B2 (multi-step cascade approximates global optimum)
Inference form	encode history once + score candidates in parallel	autoregressively decode the whole list
Candidate pool guarantee	Upstream-given / ANN index	constrained decoding + Trie pruning
Output per request	top-N candidate scores	a whole session list

This difference determines the deployment difficulty of the two —HSTU lands in one cascade layer, can be progressively replaced inengineering; OneRec is an end-to-end replacement of cascade, with muchlarger engineering scope, but also a much higher ceiling.

OneRec is currently one of the most complete and typical industrialcases of end-to-end GR replacing cascade in public materials. Theoriginal paper OneRec(arXiv:2502.18965) only reported one deployment number — main-sitewatch-time +1.6%; more complete deployment data comes from the follow-upOneRec Technical Report(arXiv:2506.13695):

Kuaishou main app + Lite version short video main scenarios: bearsabout 25% QPS; App Stay Time +0.54% main site, +1.24% Lite version(OneRec + RM Selection vs traditional cascade); LT7 +0.05% main site,+0.08% Lite version. The paper notes that at Kuaishou, a 0.1% App StayTime improvement and 0.01% LT7 improvement already counts asstatistically significant
Local life services scenario: GMV +21.01%, order volume +17.89%,paying users +18.58%, new customer acquisition efficiency +23.02%,already 100% QPS fully switched (OneLoc series work, see arXiv:2508.14646)
Operating cost (OPEX) is only 10.6% of the traditional solution

But Route 2 also has its limitations:

Independent validation still limited: OneRec /OneLoc / OneRec V2 all come from the Kuaishou technical lineage; publicmaterials already cover short video, local life and other scenarios, butstill lack same-level end-to-end validation from a second company inmain recommendation scenarios. In contrast, Route 1 (HSTU) has Meta(HSTU multi-product deployment) + Meituan MTGR (arXiv:2505.18654, MTGR-largefully deployed on Meituan take-away recommendation main traffic) — twoindependent deployments.
Large refactoring scope: end-to-end replacement ofcascade means the entire recall/ranking/reranking chain must berefactored, much larger than HSTU replacing one layer.
Inference latency challenge: autoregressivelydecoding the whole list is inherently disadvantageous; OneRec V2’s LazyDecoder-Only architecture is the latest engineering progress in thisdirection.

OneRec’s detailed RL alignment method (Iterative PreferenceAlignment) will be expanded separately later; here we only discuss itsposition among the three routes.

Route 3: Directly ReusingGeneral LLMs

The core thesis of this route: general LLMs have already learned richworld knowledge and text understanding capability; just rewriterecommendation as a prompt / instruction task — no need to train arecommendation foundation model from scratch.

Looking at three representative works in chronological order revealsthe evolution logic of “letting LLMs do recommendation”: from initially“let the LLM generate everything”, gradually retreating to “let the LLMonly do fine-ranking scoring” — each retreat was forced by the realconstraints of recommendation scenarios.

P5 (RecSys 2022, arXiv:2203.13366): theearliest full-textualization attempt

P5’s idea is “fully language-ize recommendation” — based on T5encoder-decoder (223M parameters), all recommendation data (user-iteminteractions, user descriptions, item metadata, reviews) is turned intotext prompts, then pre-trained with a shared language modeling objectiveon multiple tasks. P5 unified five task types:

Rating prediction: predict rating for a user-item pair
Sequential recommendation: predict next item given a historicalinteraction sequence
Explanation generation: generate recommendation rationale text
Review summarization: summarize long reviews into titles
Review preference prediction: predict rating from reviews

P5’s most critical design choice: item IDs are split intosub-word tokens — e.g., item_7391 is tokenizedinto item, _, 7391 threesub-words. This means items can be autoregressively generated by thedecoder, exactly like an LLM generating natural language. P5’s pitch is“one model, multi-task + zero-shot generalization” — after pre-trainingit can generalize to unseen prompts and new items.

But P5 has an obvious problem: item IDs are generated as texttokens, with no mechanism to ensure the generated ID falls in the validitem pool. The model might generate a non-existentitem_99999, or an ID that’s semantically reasonable but notin the pool. This is the inevitable cost of treating recommendation asNLP — the LLM’s vocabulary is open, but the recommendation scenario’sitem pool is closed.

BIGRec (arXiv:2308.08434):acknowledging that generation results need grounding

BIGRec proposed a bi-step grounding paradigm for P5’s “generated IDinvalid” problem:

Step 1 (grounding): fine-tune the LLM to generateitem-description-related tokens, “grounding” the LLM from language spaceto recommendation space
Step 2 (matching): use the LLM’s latentrepresentation to map generated tokens to the closest valid item

That is, BIGRec no longer expects the LLM’s generated token sequenceitself to be a valid item ID, but treats it as a “semantic anchor”, thenuses nearest-neighbor search to map back to the valid item pool. This issimilar in spirit to “the output layer is two-tower dot product + ANNretrieval” in the HSTU route — both acknowledge the generation sidecan’t directly guarantee validity and need post-processing mapping.

But the BIGRec paper also reveals a deeper finding: the pureLLM route’s efficiency and stability in learning collaborative signalsis still insufficient. The paper observed that increasing thenumber of training samples brings limited marginal gains for BIGRec —because the LLM’s strong semantic prior suppresses learning ofstatistical information (e.g., popularity, collaborative filteringsignals). This point is key to the overall judgment of Route 3: what theLLM learns in pre-training is “semantic associations in language”, not“collaborative associations in user behavior” — the former is semanticsignal, the latter is statistical signal, and the two are notequivalent.

LlamaRec (PGAI@CIKM 2023, arXiv:2311.02089): just giveup generating items, let the LLM only do fine-ranking

LlamaRec’s idea: since LLM item generation has validity andefficiency issues, then simply don’t let the LLM generateitems, only let it do fine-ranking scoring. Specifically twostages:

Stage 1 (recall): use a traditional sequence model(SASRec/LRURec) for recall, pulling back a candidate item set
Stage 2 (fine-ranking): feed user history andcandidate items as text to the LLM, use a verbalizer to directly map LLMoutput logits to a probability distribution over candidate items

The key is the verbalizer trick — mapping eachcandidate item to a specific token (or set of tokens) in the LLM’svocabulary, so one forward pass reads out all candidates’ logits, noautoregressive generation needed. LlamaRec uses LLaMA-2-7b + LoRAfine-tuning; the verbalizer lets it complete all candidate scoring inone forward pass, bypassing the slowness of LLM autoregressivedecoding.

This design is clever: it changes the LLM’s output layer from“generator” to “scorer” — the LLM no longer generates items,just uses its semantic understanding capability to score candidateitems. This is similar in spirit to HSTU’s “output layer is two-towerdot product”: both “use the model to encode a query/user state, thenscore candidate items”; HSTU’s backbone is a sequence model, LlamaRec’sbackbone is an LLM.

The evolution logic reflected by the threepapers

Putting the three together, Route 3’s evolution direction is veryclear:

Paper	Year	LLM’s role	How item validity is guaranteed
P5	2022	Generate item ID	Not guaranteed (generated tokens may not be a valid ID)
BIGRec	2023	Generate item description tokens	Post-processing mapping (latent nearest neighbor)
LlamaRec	2023	Score candidate items	Candidates given by upstream (LLM not responsible forgeneration)

The evolution direction is: from “let the LLM generate items”gradually retreating to “let the LLM score”. Each retreat wasforced by real constraints of recommendation scenarios:

P5 doesn’t guarantee validity → BIGRec adds groundingpost-processing
BIGRec’s grounding is still slow (generation + mapping), and thepure LLM route is inefficient at learning collaborative signals →LlamaRec just gives up generation, only does scoring
Finally LlamaRec retreats to the “LLM does fine-ranking” position —overlapping with HSTU’s position in the fine-ranking scenario, but withthe backbone swapped to an LLM

This evolution also explains why Route 3 currently has littleindustrial deployment — retreating to LlamaRec’s slot, the LLM’sadvantage over traditional fine-ranking is only “semantic understandingcapability”, but it’s at a disadvantage in inference latency,behavioral signal modeling, and training cost. The LLM’s semanticunderstanding capability has local value in “long-tail, cold-start,conversational” sub-scenarios, but in main recommendation scenarios with“huge behavioral data, strict latency requirements”, this advantage isinsufficient to overcome latency and cost disadvantages.

Two industrial extension works: HLLM and URM

P5/BIGRec/LlamaRec are all academic works, but Route 3 has twoindustrial extensions worth mentioning separately — both “use LLM ideasfor recommendation”, but took a different path from pureLLM-as-Recommender:

HLLM (ByteDance, arXiv:2409.12740):uses two layers of LLM to decouple “item content understanding” and“user behavior modeling” — the Item LLM compresses item textdescriptions into content embeddings, the User LLM does behaviormodeling on these embeddings. This decoupling is especially suitable forscenarios with “rich item content information, relatively sparsebehavioral signals” (e.g., long videos, e-commerce products), with verysignificant improvements on cold-start and long-tail — these scenariosare exactly where the LLM’s semantic understanding capability can trulyplay its value
URM (Alibaba, arXiv:2502.03041):treats recall as a “universal task” — the same model can domulti-scenario recall, multi-objective recall, and long-tail recall.Multi-query representation lets the model produce multiple queryembeddings in one inference, each query corresponding to a differentobjective / scenario. This is essentially porting the LLM’s“instruction-following” idea to recommendation recall

The common feature of these two works: they don’t let the LLMdirectly generate item tokens, but use LLM ideas to transform someinternal module of the recommender system. This is much easierto deploy industrially than P5’s “fully language-ize recommendation”route — and is one of the few directions in Route 3 with publicindustrial A/B or testing evidence.

Differences Among the ThreeRoutes

Many interpretations treat HSTU, OneRec, LLM-as-Recommender as“similar things”, but looking closely, their starting points, what theyreuse, and what scenarios they suit are all completely different:

Dimension	Route 1 (HSTU)	Route 2 (OneRec)	Route 3 (LLM-as-Recommender)
Starting point	Train from scratch on recommendation data	Train encoder-decoder from scratch on recommendation data	Fine-tune from pre-trained LLM
What it reuses	Scaling law itself	Scaling law + semantic ID + end-to-end	LLM’s world knowledge + text understanding
Generates item tokens	No (two-tower dot-product scoring)	Yes (autoregressively generates semantic ID)	Partially generates (P5/BIGRec), partially scores (LlamaRec)
Key signal	Behavior sequence	Behavior sequence + item representation structure	Text description
Challenged assumptions	B1 (pointwise) + C (scaling law)	B2 (multi-step cascade) + C (scaling law)	Mainly B1 (LLM replaces scoring)
Suitable scenarios	Feed / short video with huge behavioral data	End-to-end unifying recall + ranking + slate	Long-tail, cold-start, conversational
Inference latency	Medium (specialized architecture can be deeply optimized)	High (autoregressively decode whole list)	High (general LLM decode slow)
Industrial deployment evidence	Meta (HSTU multi-product deployment) + Meituan MTGR (arXiv:2505.18654)	Kuaishou main app + Lite version deployment	Almost none in main scenarios, some in local scenarios
Deployment difficulty	High, but validated feasible by Meta	Very high, large engineering scope	High, very few industrial cases
Industrial evidence strength	Validated (paradigm-level contribution)	End-to-end evidence relatively complete, but mainly from onetechnical lineage	Academically valid, industrially unvalidated
Main bottleneck	No obvious bottleneck; Meta (HSTU) + Meituan (MTGR) two independentbig-company validations	Large refactoring scope, severe inference latency, public evidencemainly from one technical lineage	Insufficient behavioral signal injection + inference latency hard tocompress to tens of milliseconds; onlylong-tail/cold-start/conversational has local value

Decoding& Inference: Letting Generated Tokens Land on Real Items

Core question: the generated token sequence may notcorrespond to any real item at all

A token sequence sampled from an autoregressive model can be anynatural language in a normal LLM scenario. But in GR, the generatedsemantic ID must be mappable back to a real, currently valid, currentlyunblocked item. Otherwise the recommendation result is just air.

Engineering has several standard approaches to this problem. Below weuse OneRec as a concrete example to tie this mechanism together —TIGER’s mechanism is essentially the same, just not deployedindustrially.

Beam search: avoid greedily discarding high-probability pathstoo early

The most basic approach. Greedy decode picks the highest-probabilitytoken each step, but semantic ID is a multi-token sequence — some pathmay have high first-step probability but no way forward next step(remaining tokens all invalid), and greedy gets stuck. Beam searchsimultaneously maintains top-k candidate paths and expands them inparallel, finally picking the highest-total-probability completepath.

OneRec’s beam size is on the order of 128 — meaning each step mustmaintain 128 paths’ KV cache and probabilities simultaneously, puttingpressure on both memory and bandwidth. This number directly determinesthe latency floor of decoding.

Constrained / prefix-aware decoding: doing softmax only onthe valid set

Beam search solves “which path to pick”; constrained decoding solves“at each step, only do softmax on valid tokens”. At each decode step,first mask out all invalid tokens, then do softmax and sample,eliminating the generation of air items at the source.

The hierarchical structure of semantic IDs makes this step naturallyfit a Trie:

Layer-1 tokens can only be chosen from “layer-1 codebook indicesthat appeared in the training set”
Layer-2 tokens can only be chosen from “layer-2 combinations thatappeared in the training set given the layer-1 token”
And so on

That is, the prefix of a semantic ID alone can prune most invalidpaths. OneRec pre-organizes all valid semantic IDs into a Trie; duringdecoding, each step advances one node on the Trie, and the next step’svalid token set is exactly this node’s child key set — one maskoperation completes the constraint.

This point is a key engineering trick used by both TIGER and OneRec,and is the engineering reason for Route 2’s “strong dependence onsemantic ID” — without RQ-VAE encoding items into hierarchical-prefixsemantic IDs, constrained decoding degenerates into masking all itemIDs, losing the prefix-pruning efficiency advantage.

Relationship with ANN

There’s a common misunderstanding to clarify: GR’s generative recallis not “replacing ANN”; a more accurate statement is “usingtransformer memory to replace the ANN index”. That is, recallbecomes “the model parameters themselves are theindex”, not “model + external index”. This distinction mattersengineering-wise: model retraining means index retraining, modeldeployment means index deployment, the two can no longer be deployedindependently.

Industrial latency constraints: the biggest bottleneck ofautoregressive decoding

Traditional fine-ranking finishes in tens of millisecondsindustrially; autoregressive decoding is inherently disadvantaged — eachtoken requires one forward pass. Generating a session of 5-10 items,each with 3-4 layers of semantic ID tokens, totals 15-40 forward passes,plus beam size 128 parallel expansion — naive implementation’s latencyis completely unusable.

OneRec’s deployment relies on several engineering optimizationsstacked to bring latency down:

KV cache: reuse encoder hidden states and K/V ofalready-generated tokens, avoiding recomputing history each step
MoE sparse activation: decoder FFN uses MoE; eachtoken activates only a few experts, actual compute much less than adense model — this lets the model scale to 2.6B parameters while stillfollowing the scaling law, without single-step latency exploding
float16 / low-precision inference: further compressmemory and bandwidth

OneRec V2 (arXiv:2508.20900)‘s LazyDecoder-Only architecture claims to reduce total compute by 94%,training resources by 90%, and scale the model to 8B parameters — thelatest engineering progress in this direction. Its core idea is to delaysome tokens’ decoding, only running the full decoder when truly needed,reducing wasted computation.

Constrained decoding and transformer-as-index themselves have beenvalidated as feasible by multiple industrial systems. But compared tothe mature ANN + fine-ranking chain under the cascade paradigm, thelatency overhead of autoregressive decoding remains significantlyhigher. This is why end-to-end GR has so far mainly deployed in“latency-relatively-lenient” content feed scenarios, while search andadvertising — extremely latency-sensitive — have essentially none.

TrainingObjective: From next-token to Preference Alignment

The “generative architecture” discussed in the three pillars aboveuses next-token cross-entropy training. But this loss can only optimize“the next item the user is most likely to interact with” — this is justa surrogate, not the real target recommendation cares about. Thissection separately discusses alignment mechanisms beyond next-tokenloss.

Why next-token LossAlone Is Insufficient

Four classes of problems next-token loss doesn’t solve:

Multi-objective trade-off: trade-offs among CTR,watch-time, conversion, retention; next-token can’t explicitly expressthese
Long-term value: session depth, next-day retention,repurchase — these signals are inherently delayed and sparse
Business constraints: ad load, marketing-feeldispersion, category diversity — these hard constraints are outside thegenerative model’s view
exploration: the model has only seen tokencombinations in historical logs, with no exploration motive for unseencombinations

In the LLM domain, the corresponding solution is RLHF (ReinforcementLearning from Human Feedback). GR inherits the idea of RLHF, but withseveral key differences from LLM. It needs to be pointed out up frontthat RL alignment can only solve soft-preferenceproblems (multi-objective implicit trade-offs, long-term value,exploration); as for “business constraints” — pacing, load caps, scoreshading, calibration and other hard constraints and online controlproblems — the next-token paradigm is inherently unsuited, and RL can’tsolve them either; traditional control methods are still needed asfallback (see the later “GR’s landing forms across cascade layers”section on the second-layer mix-rank discussion).

OneRec’s IterativePreference Alignment

OneRec(arXiv:2502.18965) is currently the most representative industrialRL alignment solution in GR. Its approach has five steps:

Step 1: train a reward model $R_\phi$

Input is a session-level generated sequence (i.e., a list of itemsrecommended to the user), output is a scalar reward. The reward’straining labels come from multi-objective business results — watch-time,engagement, conversion and other real metrics.

Step 2: use the current policy to generate candidatesessions

Use the current GR model (policy $\pi_\theta$) to generate $K$ candidate sessions $\{\pi^{(1)}, \dots, \pi^{(K)}\}$ via beamsearch. Here $\pi$ denotes a completerecommendation session (not the $\pi$in the math symbol $\pi_\theta$);context will distinguish clearly.

Step 3: construct preference pairs

Use the reward model $R_\phi$ toscore each candidate; the highest-reward one is chosen ($\pi^+$), the lowest-reward one is rejected($\pi^-$).

Step 4: NTP + DPO joint alignment

OneRec in the IPA stage does not only use DPO loss,but adds next-token loss and DPO loss weighted as a joint trainingobjective:

\[\mathcal{L} = \mathcal{L}_{\mathrm{NTP}} + \lambda\mathcal{L}_{\mathrm{DPO}}\]

Where the DPO loss’s specific form is:

\[\mathcal{L}_{\mathrm{DPO}} = -\,\mathbb{E}\left[\log \sigma\!\left(\beta\log \frac{\pi_\theta(\pi^+)}{\pi_{\mathrm{ref}}(\pi^+)} - \beta \log\frac{\pi_\theta(\pi^-)}{\pi_{\mathrm{ref}}(\pi^-)}\right)\right]\]

Symbol definitions:

$\pi_\theta$: current policy (GRmodel)
$\pi_{\mathrm{ref}}$: referencepolicy — in OneRec this is the previous iteration’s model $M_t$ (not a frozen SFT-stagecheckpoint), updated each iteration
$\pi^+, \pi^-$: high / low rewardcandidate sessions
$\beta$: temperature coefficient,controlling alignment strength. Larger $\beta$ → policy more tightly followspreference; smaller $\beta$ → policymore conservative
$\sigma$: sigmoid function
$\lambda$: DPO loss weight. Inthe paper, DPO samples are about 1% of NTP samples; $\lambda$ balances the magnitudes of thetwo losses

Two key points to emphasize here:

NTP loss always retained: even in the IPA stage,next-token loss is not dropped — it’s trained jointly with DPO loss as acombined loss, serving as an anchor preventing the policy from driftingtoo far. If only DPO loss is kept and NTP loss dropped, the policy willquickly be led astray by the reward model’s bias
Reference policy is dynamic: unlike LLM RLHF’spractice of “freezing the SFT checkpoint as reference”, OneRec’s $\pi_{\mathrm{ref}}$ is the previousiteration’s model $M_t$, updated eachiteration — this is another meaning of “iterative”

In plain terms, this joint loss wants to: make the policy’srelative probability of outputting $\pi^+$ higher than $\pi^-$ (DPO part), while not drifting toofar from the reference policy ($\beta$ term), and still doing well onnext-token prediction (NTP part).

Step 5: iterate

After jointly training with $\mathcal{L} =\mathcal{L}_{\mathrm{NTP}} + \lambda \mathcal{L}_{\mathrm{DPO}}$to get $M_{t+1}$, use $M_{t+1}$ as the new policy to regeneratecandidates, re-score with the reward model, reconstruct preferencepairs, and jointly train $M_{t+2}$.In each iteration, NTP loss participates in training together with DPOloss, not dropped when switching to the alignment stage. This iterativeprocess is the source of “Iterative Preference Alignment” in OneRec’sname.

Summarizing the whole training flow: first train a seed model withpure NTP loss (SFT stage) → enter the IPA stage, where each iterationjointly trains with $\mathcal{L}_{\mathrm{NTP}} + \lambda\mathcal{L}_{\mathrm{DPO}}$, with the reference policy being theprevious iteration’s model (dynamically changing).

TheEssential Difference Between GR’s RL and LLM’s RLHF

Comparing OneRec with LLM’s RLHF, the most critical difference isthe source of preference pairs:

In LLM’s RLHF, preference pairs are obtained by human annotatorscomparing item by item. NLP’s output space is natural language, withcontrollable annotation cost.

In GR, no one wants to compare recommendation lists item by item —each recommendation is several to dozens of items, annotating onesession takes minutes, doesn’t scale. So GR’s preference pairsare synthesized from a reward model: the reward model itselfsimulates user behavior and generates preferences itself.

The cost of this is very large. It means GR’s RL alignmentessentially becomes “model-based RL on a learnedsimulator” — the simulator’s (reward model’s) own bias is a newsource of risk. If the reward model is learned inaccurately, the wholealignment runs in the wrong direction. This point isn’t specificallyemphasized in the OneRec paper, but is a pit that must be stepped onindustrially.

It needs to be further pointed out that the reward model itself isalso trained from historical user behavior logs — its training labelsare usually a weighted combination of watch-time, engagement, conversionand other business metrics. This means the reward model learns “thepreference distribution that has appeared in historical logs”, with nojudgment for unseen item combinations. So GR + RL alignment essentiallybears two layers of bias: (1) the reward model’s bias as a simulator,(2) the bias in the reward model’s training labels (multi-objectiveweighting + historical log coverage). The second layer of bias is thesame problem as traditional multi-objective recommendation modeling, butbecause GR relies on the reward model to synthesize preferences, thisbias gets amplified by DPO.

GR’s Landing FormsAcross Cascade Layers

This section is an explicit echo of the previous article 《PersonalizedRanking Formula》 — mapping the GR paradigm layer by layer back tocascade, to see which layer is overturned, which is reopened, and whichremains unsolved.

The previous article divided recommendation into three layers:

First layer fine-ranking: single item scoring $s(u,i,x)$
Second layer mixed ranking: business-level trafficallocation, online control with constraints
Third layer re-ranking: list combinationoptimization, including listwise / Slate

Adding recall, cascade is actually four layers. GR’s correspondingform across these four layers is completely different, as summarizedbelow:

Cascade stage	Traditional approach	GR corresponding form	Representative work	Industrial deployment
Recall	Two-tower + ANN	TIGER: generative recall (transformer memory replaces ANN); HSTU:sequence modeling + ANN (user encoder upgrade, item side unchanged)	TIGER / HSTU	TIGER academically valid, industrial-scale recall unvalidated; HSTUHigh (Meta deployment)
First-layer fine-ranking	pointwise / multi-objective weighted	Autoregressive Ranking	HSTU	High (Meta deployment)
Third-layer re-ranking / Slate	listwise + Generator-Evaluator	Directly generate slate	OneRec, Seq2Slate family	Medium (Kuaishou deployment)
Second-layer mixed ranking (businessallocation)	calibration + multiplier + pacing + score shading	Hard constraints / online control — GR doesn’t solvecurrently	—	Low

The first three layers’ details on TIGER / HSTU / OneRec have beencovered in the three pillars above; here we only point out theircorrespondence to cascade layers. Among them, GR on the recall sideactually has two different routes (TIGER generative recall vs HSTUsequence-modeling recall) that need to be examined separately.What this section really wants to say is the last row — the hardconstraints and online control part of the second-layer mixed ranking isa blind spot that the next-token paradigm is inherently unsuited for andGR currently can’t well satisfy, expanded separately at theend.

Recall

Traditional recall uses user/item two-tower learning of embeddings,builds ANN index offline, and does approximate nearest-neighborretrieval online. GR on the recall side actually has two differentroutes, corresponding to the two kinds of works discussed above:

HSTU route: sequence-modeling recall — doesn’tgenerate item tokens, just upgrades the user-side encoder in thetwo-tower to HSTU sequence model, projects a stronger user state $A_t$ into a query embedding, then feeds itto the ANN index for retrieval; the item side is still hash ID +embedding + ANN (see the earlier Route 1 HSTU output layer discussion).This route retains the engineering advantage of ANN index beingindependently deployable and updatable, but sacrifices the ability to“generalize to unseen items”.
TIGER route: generative recall — given ahistorical behavior sequence, autoregressively generates the next item’ssemantic ID (see the earlier Item Tokenization section). The mostessential difference between this and two-tower recall is not “adifferent retrieval method”, but gives the recall side for the firsttime the ability to generalize to unseen items. In two-tower recall,items not in the training set can hardly be recalled; in GR recall, aslong as the new item’s semantic ID falls in the learned prefix space, itmay be generated. The cost is that transformer memory itself is theindex; model retraining means index retraining, and the two can nolonger be deployed independently (see the earlier “Relationship withANN” section).
Two levels need to be distinguished — recall taskand industrial-scale recall — TIGER has only beenvalidated at the first level:
- Recall task level (validated): the TIGER paperindeed does recall-task experiments — given user history, generate thenext item’s semantic ID, then do constrained decoding to map back toreal items. This itself is the form of a recall task; the paper title“Generative Retrieval” also clearly positions TIGER as generativerecall.
- Industrial-scale recall level (unvalidated):TIGER’s benchmarks are academic datasets like Amazon Reviews, with SOTAcomparisons mainly against sequence-recommendation models like SASRec /BERT4Rec, not two-tower recall models; it also didn’texperiment in industrial recall scenarios with million/billion-scaleitem pools + ANN indexes. So “vs two-tower + ANN” is more aparadigm-level comparison (transformer memory replaces ANN index), not aconclusion directly drawn from the paper’s experiments.
This two-level distinction is the root cause of TIGER’s “opens newpossibilities” but relatively weak industrial deployment evidence — itproved on academic benchmarks that generative recall as a task isfeasible, but whether industrial-scale recall can outperform the mature“two-tower + ANN” chain has no public evidence yet.

The industrial deployment of these two routes differs greatly: theTIGER route has only been validated on academic benchmarks (e.g., AmazonReviews, comparing against sequence-recommendation models like SASRec /BERT4Rec) for the feasibility of generative recall as a task itself,with no experiments in industrial recall scenarios withmillion/billion-scale item pools + ANN indexes, and no public deploymentevidence; the HSTU route comes with traffic naturally as HSTU deploysacross multiple Meta products. In other words, the GR form thathas actually been deployed industrially on the recall side is HSTU’s“sequence modeling + ANN” route, not TIGER’s “fully generative”route — the latter is more like “a direction opening newpossibilities”, the former is “a validated deployment form”.

First-Layer Fine-Ranking

HSTU is the most fundamental challenge to cascade’s first layer — nolonger pointwise scoring, but next-action sequenceprediction (reframing recommendation from “per-$(u,i)$ scoring” to “given a historicalbehavior sequence, predict what behavior is most likely next”). Nolonger making “multi-objective weighting” central, but using scaling law+ large model capacity to automatically learn implicit trade-offs amongmulti-objectives (see the earlier Route 1).

The only point to emphasize here, distinct from the three pillarsabove: HSTU challenges the mathematical form “first-layerscoring formula $f_\theta(u,i,x)$”from the previous article itself, not item representation. HSTUdoesn’t use semantic ID; the official implementation is mostly stillhash-based — meaning even a team that doesn’t plan to switch to semanticID can independently try HSTU. This point is the root cause of thedifference in deployability between fine-ranking and recall layers inGR.

Third-Layer Re-Ranking /Slate

OneRec (arXiv:2502.18965) uses anencoder-decoder to generate the whole list in one go, the most naturalevolution of the third layer in the previous article.

The previous article divided third-layer methods into three classes:constrained re-ranking, list re-ranking, Slate optimization. The mostcommon industrial implementation of “list re-ranking” isGenerator-Evaluator: the generator produces multiplecandidate arrangements, the evaluator scores each arrangement’s overallutility. OneRec unifies these two things in one transformer:

The decoder is both generator (autoregressively generatesarrangements) and implicitly serves as evaluator via next-tokenloss
Training uses RQ-VAE semantic ID to represent items, making“adjacent items” also adjacent in token space
Uses DPO for preference alignment (see the earlier “TrainingObjective: From next-token to preference alignment” section)

That is, OneRec unifies listwise and Slate in one generativeframework, as the “next-generation form” of the previousarticle’s third layer.

This is the most important paragraph in this section, and also themost easily overlooked.

In the previous article, the second-layer mixed ranking does“multi-business, constraint-bearing trafficallocation”: calibration, multiplier, pacing, score shading,minimum traffic protection, ad load caps… these problems need to bedistinguished into two classes:

Soft-preference class (implicit trade-offs amongmulti-objectives, user preference alignment) — this part can be put intothe GR framework, learned via DPO / reward alignment (see the earlier“Training Objective: From next-token to preference alignment”section)
Hard-constraint + online-control class (pacing,load caps, score shading, calibration) — this part is a blind spot thatthe next-token paradigm is inherently unsuited for and GR currentlycan’t well satisfy

The common feature of the latter class: they’re not “predict the nexttoken” problems, but “online control under constrained resourceconditions” problems.

The next-token paradigm is inherently unsuited to express this classof problems:

Pacing controllers need long-time-window feedback accumulation;next-token loss is stepwise
Load constraints are hard constraints, not soft preferences;DPO-style reward alignment is unsuited to express them
Score shading is essentially an online estimation of a dual variable(shadow price), more like a control theory problem than a generationproblem
Each business’s calibration magnitude alignment is also not solvableby “generation”

So even if a team fully switches to GR, the hard constraints andonline control part of the business-level mixed ranking layer (secondlayer) still need to retain traditional methods. This is a veryimportant but rarely paper-discussed fact about GR industrialdeployment.

Overall, GR is disruptive for the first layer (HSTU), opensnew possibilities for recall — TIGER’s fully generative recall is “thedirection of new possibilities”, HSTU’s “sequence modeling + ANN” is“the validated deployment form”, and is unifying for the third layer(OneRec); the soft-preference part of the second-layer mixed ranking canbe put into the GR framework, but the hard-constraint and online-controlpart (pacing / load / score shading / calibration) the next-tokenparadigm is inherently unsuited for, and traditional methods must beretained.

Practical FeasibilityJudgment

This section consolidates the judgments scattered throughout thearticle into an actionable checklist. To judge whether GR is feasiblefor a specific business, the key is not “whether it’s hype overall”, butto break it into several independent technical points — each withdifferent industrial evidence strength. Below we first go through theevidence point by point, then land on “what business should try now” and“how to try”.

Technical point	Industrial evidence	Main basis
Semantic ID / RQ-VAE	Validated	TIGER experiments sufficient; OneRec, HLLM all depend on it;prerequisite for the “generate item token” route
HSTU + recommender scaling law	Validated (strongest)	Meta 1.5T-parameter deployment
End-to-end GR replacing cascade	Short video / local life has public validation, independentvalidation still limited	OneRec / OneLoc / OneRec V2 etc. Kuaishou technical lineage casesare relatively complete, but cross-company validation insufficient
LLM-as-Recommender (P5 / BIGRec / LlamaRec)	Academically valid, industrially unvalidated	Benchmarks look good; two fundamental problems — latency andbehavioral signal injection — unsolved
GR + DPO preference alignment	Short video validated, sparse reward unsolved	OneRec effective on watch-time; sparse-reward scenariosunsolved
GR for cold start	Strong evidence	semantic ID + content encoder naturally carries semantic structure;HLLM long-tail experimental evidence
GR replacing business-level mixed ranking	GR alone cannot replace	pacing / load / calibration still need external controllers andtraditional online control mechanisms
GR inference latency	Still a bottleneck	OneRec V2 cutting 94% compute is progress, but still higher thancascade

If a business simultaneously meets multiple of the following, tryingGR is worthwhile:

Behavioral data volume large enough: scaling lawcan take effect. A rough empirical threshold is hundred-million-DAU,billion-level daily interactions
Main feedback dense and timely: short videowatch-time, feed dwell time — this dense reward is the prerequisite forGR + RL alignment to work
Strong need for item content understanding / coldstart: content platforms, UGC platforms, cross-domainrecommendation
Recall is clearly a bottleneck: two-tower recallceiling obvious, long-tail coverage poor — then generative retrieval isthe most direct entry point for gains
High list-combination quality demand with relatively singleobjective: feed scenario slate generation benefits most

Conversely, if a business has any of the following characteristics,then in the short term GR is not recommended as the main direction:

Strong constraints, strong multi-objective:advertising, e-commerce scenarios simultaneously managing load, pacing,calibration, revenue. GR can learn some soft preferences, but can hardlybear these hard constraints and online control alone
Inference latency extremely sensitive: search, adRTB with tens-of-millisecond budgets
Business data scale not large enough: scaling lawcan’t kick in, instead dragged down by the general architecture
Main feedback sparse and delayed: scenarios wherelong retention, repurchase, conversion are the main objectives

If deciding to proceed with GR, a relatively robust path isphased:

First deploy semantic ID, gradually replacing hashID. This step, even without full GR, can yield cold-start and long-tailgains
On the recall side, do a generative retrievalpilot, parallel small-traffic validation with the existingtwo-tower recall
On the fine-ranking side, try HSTU-style scalingexperiments, first seeing whether scaling law really holds onyour business — this is the key decision point for follow-upinvestment
After 1-3 are all validated, then consider slate generation+ DPO alignment
Business-level mixed ranking layer (constrained allocation) retainstraditional methods; don’t try to replace everything with GR

The logic behind this path: each step retains retreat room, eachstep’s ROI can be independently evaluated. Compared to directly“end-to-end deploy GR”, industrial risk is much lower.

Summary

Returning to the title’s question: what GR replaces is notthe cascade system form itself, but part of the modeling assumptionsbehind cascade.

It first replaces the assumption that “items are just unstructuredIDs”. Semantic ID / RQ-VAE turns an item from a hash key into a tokenwith hierarchical structure, which is key for cold-start, long-tail, andgenerative recall. But this mainly serves the TIGER / OneRec “generateitem token” route, and is not a prerequisite for all GR forms.

It also replaces part of the assumption that “each item can be scoredindependently”. HSTU pushes recommendation from pointwise scoring tobehavior sequence modeling, and demonstrates the recommender model’sscaling law at large-scale compute; OneRec goes further, compressingrecall, ranking, and slate generation into one end-to-end generativeframework. Both are called GR, but their engineering meaning iscompletely different: HSTU is more like a strong backbone in the cascadesystem, OneRec is what challenges the overall cascade chain.

But GR does not replace business-level mixed ranking and onlinecontrol. Pacing, load, calibration, score shading — these problems areessentially constrained resource allocation, not next-token prediction.GR can learn soft preferences and partial multi-objective trade-offs,but hard constraints still need external controllers and traditionalmechanisms as fallback.

So the more accurate judgment is: GR is not the end ofcascade, but reopens several key links in the recommendersystem. The industrial evidence for semantic ID and HSTU isalready fairly strong; end-to-end GR, represented by the OneRectechnical lineage, has public validation in short video and local lifescenarios, but cross-company independent validation is still limited;LLM-as-Recommender in the main recommendation chain is still more likelocal augmentation, with value mainly in long-tail, cold-start, contentunderstanding, and conversational scenarios.

If a business has huge behavioral data, dense timely feedback, andrelatively single constraints, GR is worth systematic investment; if thebusiness is extremely latency-sensitive, has many hard constraints, andsparse delayed rewards, GR is more suitable as a local moduleexperiment, not a direct replacement of the whole cascade.

References

Understanding ScalingLaws for Recommendation Models (Ardalani et al.,arXiv:2208.08489)
Recommender Systems withGenerative Retrieval (TIGER, NeurIPS 2023)
Actions Speak Louder thanWords: Trillion-Parameter Sequential Transducers for GenerativeRecommendations (HSTU, ICML 2024)
OneRec: Unifying Retrieveand Rank with Generative Recommender and Iterative PreferenceAlignment
OneRec TechnicalReport
OneRec-V2 TechnicalReport
OneLoc: Geo-AwareGenerative Recommender Systems for Local Life Services
HLLM: EnhancingSequential Recommendations via Hierarchical Large Language Models forItem and User Modeling
Large Language Models AreUniversal Recommendation Learners (URM)
P5: Recommendation asLanguage Processing
LlamaRec: Two-StageRecommendation using Large Language Models for Ranking
BIGRec: A Bi-StepGrounding Paradigm for LLMs in Recommendation
MTGR: Industrial-ScaleGenerative Recommendation Framework in Meituan (KDD 2025)
PersonalizedRanking Formula: From Personalized Fine-Ranking to PersonalizedMixed-Ranking to Global Re-Ranking (previous article on thisblog)

生成式推荐 GR：它到底在替代什么，又没替代什么

2026-07-12T05:00:00.000Z

“生成式推荐” 最近一年是推荐系统里出现频率最高的词之一，但它在不同人嘴里其实指代的是完全不同的东西。一篇讲LLM 接推荐的论文叫它 “生成式推荐”，一篇讲 RQ - VAE 做 semantic ID的工作也叫它 “生成式推荐”，一个把召回 - 排序 - 重排合成一个 encoder-decoder的工业系统也叫它 “生成式推荐”。

但这三件事在工程意义上几乎没有交集。

把它们混在一起讨论，就会出现两种很常见但都不太严谨的判断：

一种是 “GR 还只是噱头，工业用不上”
另一种是 “cascade 范式要被全面颠覆了”

这两种判断都假设 “GR” 是一个东西。但只要稍微拆一下就会发现：semantic ID已经在多家厂上线、HSTU 在 Meta 上线、OneRec 在快手上线（至少 paper是这么说的），与此同时大多数 LLM-as-Recommender类工作的工业落地证据仍然非常少。这显然不是 “GR 是不是噱头” 这种 0 / 1问题能描述清楚的。

所以本文真正想讨论的，不是 “GR是不是未来”，而是这样一组更具体的问题：当cascade（召回 - 粗排 - 精排 - 重排）已经支撑了十几年的工业推荐系统之后，GR究竟在挑战哪一条假设？它替代了什么、又没替代什么？哪些已经被工业验证、哪些还停留在论文层面？

为了避免后面分章节的细节淹没主线，先把全文的主张提前讲一句：GR不是 cascade 的全面替代，而是给 cascade的每一环都打开了一扇 “用生成方式重新解题” 的门。但每扇门后面的工业难度差别极大，需要分层去看，不能一概而论。

Cascade 范式的三个隐含假设

要理解 GR 在挑战什么，先要把 cascade 范式的隐含假设拆清楚。cascade范式之所以工作得很好，背后至少有三个长期成立的隐含假设。

假设 A：item 是离散原子

cascade 系统里，每个 item 用 hash ID + embedding 表征，item之间的语义关系完全靠协同信号慢慢学。这件事在过去十几年是 work的，但前提是：

行为信号足够稠密，每个 item 都能积累足够的共现
item 词表增长速度可控，embedding table 撑得住
长尾不重要、新 item 占比不高，或者冷启可以靠 side feature 兜底

这三个前提，在大体量、UGC驱动的现代内容平台上其实都开始动摇。每天新增的 item数量、长尾占比、跨域迁移诉求，都让 hash ID 这套体系越来越吃力。

假设 B：每一步可以独立打分

这正是上一篇文章《个性化排序公式：从个性化精排到个性化混排再到全局重排》讲的：第一层做pointwise $s(u,i,x)$，第二层做混排，第三层做 listwise/ Slate。这个假设其实包含两个层面：

B1：每个 item 可以独立打分（pointwise）—— 给定 $(u,i)$，模型单独给出一个分数，不依赖列表里其它 item
B2：多步级联能近似全局最优 —— 召回、精排、重排分层处理，假设” 局部最优累加起来≈全局最优”

这种分层之所以成立，是因为 cascade默认局部最优能近似全局最优。

但列表内 item-item相互作用不可忽略 —— 疲劳、互补、替代、位置依赖 —— 这个假设就会被打破。于是listwise re-ranking、Generator-Evaluator、Slate optimization这些方法被迫从” 后处理工具” 变成” 一等公民”。

假设C：推荐场景不存在显著的 scaling law

这是过去很长一段时间不愿意承认、但又一直接受的事实：DLRM风格的模型在参数维度上的 scaling 早就饱和了。

Meta 在 2022 年的 Understanding Scaling Laws forRecommendation Models (Ardalani et al., arXiv:2208.08489)里第一次系统量化了这件事 ——DLRM 模型质量在数据和 compute维度上仍然遵循 power law + constant 的形式，但参数维度的 scaling已经 “out ofsteam”，继续加大参数带来的边际收益迅速消失。HSTU论文在自己的 baseline 实验里又一次展示了同样的现象：传统 DLRM 的quality-compute 曲线很快进入平台期，而 HSTU 的曲线则在三个数量级 compute上持续遵循 power law。

这也正是推荐模型长期停留在亿级参数尺度的根本原因 —— 不是不想加大，而是加大没有收益。背后的微妙之处在于：不是 “推荐数据不够多”，而是 “传统DLRM 架构在大规模行为序列上的表达能力被自身设计限制住了”。

GR 真正挑战的，恰好就是这三条假设：

假设	cascade 的预设	GR 的挑战方式
A. item 是离散原子	hash ID + emb，无结构	semantic ID（RQ - VAE），层级化 token
B. 每一步可以独立打分	召回→排序→重排级联	HSTU 挑战 B1（序列建模替代 pointwise）；OneRec 挑战B2（端到端生成整张列表）
C. 没有 scaling law	DLRM 加大未必更好	HSTU 在三个数量级 compute 上验证 power-law

这三条假设不是同时被挑战的，对应的 GR工作也不是同一类。后面我们会看到，semantic ID的工业证据已经相当充分；HSTU 挑战了 B1 和 C、有 Meta的真实上线案例；而” 端到端生成整张列表”（挑战B2）的公开工业证据主要来自快手 OneRec技术谱系，跨公司独立验证仍然有限。这三件事不是一回事。

GR 将推荐重述成 “序列生成”

GR 的核心范式可以先粗略写成一句话：把推荐这件事，从 “给候选 item打分排序” 重新表述成 “在用户行为序列上做生成式预测”。

但更严谨地说，GR 至少有广义和狭义两层：

广义 GR：把推荐从独立的 $(u,i)$ 判别式打分，改写成用户行为序列上的next-action / sequential transduction。HSTU 属于这一层，它不一定生成item token。
狭义 GR：进一步让模型自回归生成 item token /semantic ID，再映射回真实 item。TIGER、OneRec 属于这一层。

如果写成狭义 item-token 生成形式，可以表示为：

\[p(i_t \mid i_{

逐符号定义：

$i_t$：第 $t$ 个待生成的item（也就是 “推荐的下一个内容”）
\(i_{：用户的历史交互序列（往往是按时间排好的item 列表）
$\text{tokenize}(\cdot)$：itemtokenizer，把单个 item 映射成若干个离散 token
$u$：用户侧信息（可以是用户ID、画像、上下文等）
$f_\theta$：自回归生成模型或序列预测模型（TIGER/ OneRec 直接生成 item token；HSTU 则更接近广义的 next-action序列预测）

通俗一点说，传统 cascade 的视角是：

“给我一堆候选 item，我给每个 item 打分，然后排序输出。”

狭义 GR 的视角则是：

“给我用户过去的行为序列，我直接生成下一个 item（或下一段 item序列）。”

广义 GR 和传统 cascade 在数学形式上已经不一样；狭义 GR在工程实现上差异更大。下面这张对照表是全文的骨架：

维度	判别式 cascade	生成式推荐 GR（典型形态）
item 表征	hash ID + dense emb	semantic ID（狭义 GR）/ action token（广义 GR）
单次决策对象	单 $(u, i)$ 的 score	下一个 action / token
列表生成方式	召回 → 排序 → 重排级联	自回归 decode（可一次性生成整段）
训练目标	多目标加权 loss	next-token cross-entropy（+ 后续 reward 对齐）
Scaling Law	经验上较弱	HSTU 在 GPT-3 量级 compute 上验证存在
推理形态	矩阵乘 + ANN 检索	自回归 decode + beam search
冷启动	依赖 side feature	semantic ID 自带语义层级

这里需要做一个边界说明，避免被字面意思误导：

GR ≠ “把 LLM 接到推荐里”。LLM-as-Recommender 只是 GR的一种形态，HSTU 这种从推荐数据从头训的工作甚至不依赖通用 LLM
GR ≠ “端到端推翻 cascade”。即使是 OneRec 这种端到端GR，也仍然保留了业务级混排和约束兜底等机制
GR ≠ “一定要用 semantic ID”。HSTU 的官方实现里大部分还是 hash体系，它挑战的是假设 B 和 C，不挑战假设 A

也就是说，GR是一个范式集合，不是一个单一架构。后面三大技术支柱分别对应这个范式里三条独立但相互配合的技术线。

三大关键问题

GR 要工业落地，本质上需要解决三件事，它们恰好对应 GR范式的三个核心环节：

怎么把 item 表征成模型能生成的 token？（ItemTokenization）—— 对应” item 表征” 环节
用什么架构来做这个序列生成？（生成式架构）—— 对应” 序列建模” 环节
decode 出来的 token 序列，怎么对应回真实存在的item？（解码与推理）—— 对应” token 回落” 环节

这三件事各自有自己的成熟方法、代表工作、落地难度，必须分开看，不能混在一起评价GR 是否成熟。这也是为什么前面说” semantic ID已经工业落地、HSTU 已上线、但端到端 GR的独立验证仍然有限”—— 三个环节的成熟度完全不同。

ItemTokenization：semantic ID 与 RQ - VAE

核心问题：为什么 hash ID 撑不起 GR？

hash ID 的根本问题是相邻 ID之间没有任何语义关系。在判别式 cascade 里这没问题 —— 反正embedding 是查出来的，ID 本身只是一个查询索引，相邻 ID长得像还是不像无所谓。

但到了 GR 范式里，模型要做的事情是 “生成 ID”。这就要求 ID空间本身有结构：相似 item 的 ID 应该相似、模型才能从 “看过A” 推断出 “可能也喜欢和 A 相似的 B”。hash ID天然不具备这个性质，所以必须替换掉。

RQ - VAE 原理

Residual-Quantized VAE（RQ - VAE，残差量化变分自编码器）是目前 GR里最主流的 item tokenizer。原理可以分成两步。

第一步：训一个 content encoder $E$

它接受 item 的内容信息（文本描述、图像、行为统计、类目等），输出一个dense embedding：

\[z = E(i)\]

第二步：把 $z$ 残差量化成$L$ 个 codebook 索引

\[\begin{aligned}r_0 &= z \\c_l &= \arg\min_k \big\| r_{l-1} - e_k^{(l)} \big\| \quad l = 1,\dots, L \\r_l &= r_{l-1} - e_{c_l}^{(l)}\end{aligned}\]

逐符号定义：

$r_l$：第 $l$ 层的残差向量
$e_k^{(l)}$：第 $l$ 个 codebook 中的第 $k$ 个向量（每个 codebook都是一个可学习的向量字典）
$c_l$：第 $l$ 层匹配到的 codebook 索引
$L$：codebook层数，工业实现里通常 3-4 层

每个 item 最终被表示成一个 token 元组 $(c_1, c_2, \dots, c_L)$，称为这个 item 的semantic ID。

整个量化过程是” 用 codebook 一层一层逼近 $z$“的贪心过程。每一步都在做同一件事：”$z$ 还有多少没编码到？拿当前这一层的codebook 找一个最接近的 code 来补上”。展开来看：

初始化：$r_0 =z$，含义是” 我还什么都没编码，整个 $z$ 都待编码”。
第 1 层：在 codebook 1 里挑一个 code $e_{c_1}^{(1)}$ 使它距离 $r_0$ 最近，$c_1= \arg\min_k \|z - e_k^{(1)}\|$。然后算” 还没编到的部分”：$r_1 = z - e_{c_1}^{(1)}$。
第 2 层：第 1 层已经把 $e_{c_1}^{(1)}$ 这块” 用掉” 了，剩下的 $r_1$ 还要继续逼近。所以第 2 层在 codebook2 里挑离 $r_1$ 最近的 code：$c_2 = \arg\min_k \|r_1 -e_k^{(2)}\|$，新残差 $r_2 = r_1 -e_{c_2}^{(2)}$。
第 $L$层：以此类推，每层” 领取” 前一层留下的残差。

走完 $L$ 层后，把所有命中的 code加起来，就近似还原了 $z$：

\[z \approx \sum_{l=1}^L e_{c_l}^{(l)}\]

也就是说，semantic ID $(c_1,\dots, c_L)$ 本质上就是一组离散索引，告诉你” 怎么用 $L$ 个 codebook 里的向量把 $z$ 重新组装出来”。重建越接近$z$，semantic ID 就越能保留 $z$ 里的语义信息。

下面是一个简单的 k=3, L=3例子

$z = (1.0,\ 0.8)$
codebook 1 = $\{(1.0,\ 1.0),\ (-1.0,\0.0),\ (0.0,\ -1.0)\}$
codebook 2 = $\{(0.1,\ -0.1),\ (-0.1,\0.1),\ (0.2,\ 0.0)\}$
codebook 3 = $\{(0.05,\ -0.05),\ (-0.05,\0.0),\ (0.0,\ 0.05)\}$

semantic ID 构建过程如下

第 1 层：$r_0 = (1.0,\0.8)$。三个候选 code 离 $r_0$的距离分别约 $0.20,\ 2.15,\2.06$，最近的是第一个，所以 $c_1 =1$。残差 $r_1 = (1.0,\ 0.8) - (1.0,\1.0) = (0.0,\ -0.2)$。
第 2 层：$r_1 = (0.0,\-0.2)$。三个 code 距离分别约 $0.14,\0.32,\ 0.28$，最近的是第一个，所以 $c_2 = 1$。残差 $r_2 = (0.0,\ -0.2) - (0.1,\ -0.1) = (-0.1,\-0.1)$。
第 3 层：$r_2 = (-0.1,\-0.1)$。三个 code 距离分别约 $0.16,\0.11,\ 0.18$，最近的是第二个，所以 $c_3 = 2$。

最终 semantic ID 为 $(1,\ 1,\2)$。重建：

\[\hat{z} = (1.0,\ 1.0) + (0.1,\ -0.1) + (-0.05,\ 0.0) = (1.05,\ 0.9)\]

和真实 $z = (1.0,\ 0.8)$的重建误差 $\|z - \hat{z}\| \approx0.11$—— 层数越多、codebook 越大，重建越接近 $z$，semantic ID 编码的信息越精细。

关于这个过程有几个关键点

贪心量化：每一步只看” 这一层选哪个 code最近”，并不联合考虑后续层的选择。理论上联合优化能得到更精确的重建，但组合空间是$K^L$，不可行；贪心方案虽然不是全局最优，但训练和推理都是$O(L \cdot K)$，工程上才划得来。
量化是有损的：每一层都会留下 $\|r_l - e_{c_l}^{(l)}\|$ 的残差。$L$ 越大、$K$ 越大，重建越精确，但 token序列也越长、解码越慢 —— 这是 RQ - VAE 工程参数的根本 trade-off。

通俗一点说：就像把一本书先打粗类（“小说”），再在粗类内部打中类（“推理小说”），再在中类内部打细类（“本格推理”）。每一层都用一个小词表去刻画一个特定粒度的语义。相邻语义的item 在前缀 token 上就会重合，模型自然就学到了” 相似 item 的 ID也相似” 的结构。

为什么是” 残差 + 多层”，而不是直接一个大 codebook

这里有个很自然的疑问：如果想要 $K^L$ 个不同的 ID，为什么不直接用一个大小为$K^L$ 的codebook，做一次量化就好？

答案在于结构和泛化。一个大小为 $K^L$ 的单层 codebook 需要学 $K^L$ 个独立向量，每个 item只命中其中一个，相邻 ID 之间没有任何关系 —— 这本质上又退化回了 hashID。

RQ - VAE 不一样：每一层只学 $K$个向量，总参数量是 $L \cdotK$，但通过组合得到 $K^L$ 个semantic ID。更重要的是，第 $l$层只负责编码前 $l-1$层没编码到的信息 —— 这是” 残差” 二字的全部含义。也正因为这种递进结构，前缀token 才天然带粗粒度语义。

怎么训练

RQ - VAE 是 encoder + $L$ 个codebook + decoder 一起端到端训的。这里 decoder 重建的是 item 的连续表征$z$（或由 $z$ 对应的 item featurerepresentation），loss 由三部分组成：

\[\mathcal {L}_{\text {RQ - VAE}} = \underbrace {\|z -\hat {z}\|^2}_{\text {重建}} + \underbrace {\sum_l \|\text {sg}(r_{l-1}) -e_{c_l}^{(l)}\|^2}_{\text {codebook 学习}} + \underbrace {\beta \sum_l\|r_{l-1} - \text {sg}(e_{c_l}^{(l)})\|^2}_{\text {commitment}}\]

$\hat{z}$：decoder 用量化后的$\sum_l e_{c_l}^{(l)}$ 重建出的 item表征
$\text{sg}(\cdot)$：stop-gradient，阻断梯度回传
$\beta$：commitment 权重，VQ - VAE默认 0.25

通俗解释：

重建 loss 让整个 codebook 组合能还原 item 表征
codebook 学习 loss 让每个 codebook向量慢慢靠近实际命中它的残差均值
commitment loss 反过来约束 encoder 输出别离codebook 太远

量化操作 $\arg\min$是离散的、不可导，工程上用 straight-throughestimator（STE）解决：前向用量化值，反向时梯度直接绕过量化器传给 encoder。这是从 VQ - VAE沿用的标准技巧。

codebook 里的向量从哪来

$L$ 个 codebook不是预先定好的字典，而是和 encoder / decoder一起端到端学出来的可训练参数。每个 codebook的学习过程在直觉上等价于在残差空间里做 K-means聚类 ——$K$ 个 code慢慢演化成”$K$个常见残差的聚类中心”。具体可以用上面 loss 里 $\sum_l \|\text{sg}(r_l) -e_{c_l}^{(l)}\|^2$ 这一项直接做梯度更新，也可以用 EMA 把 code维护成” 最近一段时间命中它的所有残差的均值”（VQ - VAE论文里更推荐后者，更稳）。

训练完之后 codebook 一般被冻结，所有 item都用这套固定 codebook 量化。但工业上要注意：随着 item分布漂移、新类目出现，原 codebook 的量化质量会逐渐下降 —— 需要周 /月级定期重训 RQ - VAE，重训后所有 item 的 semantic ID也要全局重算，这是一个不可忽视的工程成本。

工程参数的常见取值

工业落地里有几个相对收敛的经验值：

参数	常见取值	说明
codebook 大小 $K$	256（或 512）	太小表达力不够、太大容易 collapse
层数 $L$	3-4	TIGER 用 4 层
有效词表 $K^L$	$\sim 10^9$ 量级	足够覆盖百亿级 item 库
commitment 权重 $\beta$	0.25	VQ - VAE 默认
codebook 向量维度	32-128	由 content encoder 输出维度决定

也就是说，一个典型配置（$K=256,L=4$）能产生约 43 亿个不同的 semantic ID，远超一般推荐系统的item 规模。

工业落地最大的坑：codebook collapse

这是 RQ - VAE 实际部署里最常踩、最少被 paper 讨论的问题。

现象：训练若干轮后，几个 codebook向量被反复命中，其余的几乎没被用过。比如 256 个 code里实际活跃的只剩 30 个。这等价于把有效词表从 $K^L$ 砍到 $30^L$，表达力急剧下降，semantic ID的层级结构也跟着塌掉。

根本原因：$\arg\min$是赢者通吃。一旦某个 code在初期被多命中几次，它的更新方向就会向命中它的那部分 item的平均向量偏移，下一轮就更容易被命中，形成正反馈。

常见缓解办法：

codebook reset：定期把长时间未命中的 code替换成” 最难被解释的残差向量”（reservoir sampling）
EMA 更新：用 exponential moving average 平滑codebook 学习，避免被少数 batch 主导
K-means 初始化：用训练集 residual 的 K-means中心初始化 codebook，避免冷启偏差
entropy regularization：在 loss 里加一项鼓励 code命中分布的熵

这些办法在原始 RQ - VAE论文和后续工作里都有提到，但实际配比和触发条件高度依赖具体业务的 item分布，往往要在线上反复调。

代表性工作：TIGER

TIGER (Rajput et al.,NeurIPS 2023, arXiv:2305.05065)是这套范式最早、也最有代表性的工作。它做了三件事：

用 RQ - VAE 给每个 item 生成 semantic ID
用一个 T5 风格的自回归 transformer 学 “给定历史行为序列，生成下一个item 的 semantic ID”
推理时用 beam search 生成候选 semantic ID，再映射回真实 item

TIGER 真正的范式级贡献，不是某个具体数字，而是它证明了一件事：

transformer memory 本身可以充当 semantic index—— 不需要单独的ANN 索引，模型参数本身就承担了召回任务。

这件事在传统 cascade视角下几乎是不可想象的：召回侧十几年来都是 “embedding +ANN” 这套范式，TIGER 第一次把它整个换成 “生成式 decoding”。

TIGER的工程细节如下：

Content encoder：sentence-T5，把 item 文本描述 encode 成 768维向量
再投影到 32 维空间做 RQ
$K = 256$，$L = 4$
为了避免不同 item 量化到完全相同的 semantic ID（hash 冲突），TIGER给每个 ID 元组多加了一个 disambiguating token（实际变成 5 个token）

最后这个细节其实很重要：即使有 $K^L\approx 4 \times 10^9$ 的有效词表，仍然会有不同 item量化到同一个 ID，需要额外 token 区分。这也是为什么 paper 里很多 semanticID 实际是 4-5 个 token，而不是干净的 4个 —— 这种” 补丁” 在工业实现里是常态。

局限性

semantic ID 不是万能的，它的几个工程边界要看清楚：

词表大小 vs 表达力的 trade-off：codebook 层数 $L$ 和每层大小 $K$ 决定有效词表是 $K^L$。$L$ 太小表达力不够、$L$ 太大 token 序列太长 decode 慢
强依赖 content encoder的质量：行为信号弱、内容信号也弱的 item（比如纯 ID型短内容）依然冷启
codebook 漂移：模型上线后，新 item 的 semantic ID怎么分配？是否要定期重训 codebook？这些是不被 paper讨论但工业必踩的坑

最后，RQ - VAE 不是 GR发明的，它在图像（VQ - VAE）和语音里已经成熟多年。它解决的 “离散 item没有结构”，是 TIGER / OneRec 这类 “生成 item token” 路线能成立的前提。HSTU这类路线的 scaling law 与 semantic ID 相对正交；但对需要自回归生成 item的路线来说，没有 semantic ID，后面的 constraineddecoding、transformer-as-index 和端到端 slate generation都很难成立。此外，即使一个团队不打算切完整的 GR，先把 semantic ID当作 side feature 注入到现有 cascade里，也已经能拿到冷启动和长尾上的收益

生成式架构的三条路线

GR的” 架构” 这一支柱目前明确分成三条路线。它们形式上都叫” 生成式”，但解决的根本不是同一个问题，可落地性也相差极大。下面按工业可落地性从高到低依次介绍。

路线一：利用推荐数据训练一个生成式基础模型

代表工作是 Meta HSTU(arXiv:2402.17152, “Actions Speak Louder thanWords”)。主要做的事情是：把 DLRM 时代的 “稀疏特征 +多塔打分” 重新表述成 “用户行为序列上的序列建模”，然后用一个为推荐场景定制的transformer 变体去把它做大。

先澄清一个容易误解的点：HSTU 里的 “生成式”，不是说它像 LLM一样生成自然语言，也不是说它一定要生成 RQ - VAE semanticID。它做的是更底层的重述：把用户历史行为看成一串 actiontoken，模型根据过去的 action 序列去预测未来 action。这里的 action可以包含 item ID、actiontype、timestamp、场景、设备、上下文特征等高基数稀疏信息。

也就是说，传统 DLRM / ranker 的输入更像一张 “当前请求的特征表”：

\[s(u, i, x) = f_\theta(\text{user features}, \text{item features},\text{context})\]

HSTU 的输入则更像一条按时间展开的行为流：

\[x_t = \mathrm{Embed}(i_t, a_t, c_t, \Delta t_t, \dots)\]

逐符号定义：

$i_t$：第 $t$ 次交互的 item
$a_t$：交互动作，例如曝光、点击、完播、点赞、购买
$c_t$：当时的上下文，例如入口、设备、地域、场景
$\Deltat_t$：时间间隔或时间位置特征
$x_t$：把这些稀疏特征融合后的第$t$ 个 action 表征

训练目标也随之改变。传统 ranker 更常见的是 “给当前候选 item打一个分”，HSTU 则是：

\[p(x_{t+1} \mid x_{\le t}) = f_\theta(x_1, x_2, \dots, x_t)\]

通俗一点说，它不是只问 “这个用户现在会不会点这个item”，而是在问 “这个用户一路走到现在，下一步最可能发生什么行为”。这就是HSTU 相比传统 pointwise ranker 更接近生成式建模的地方。

在这个框架下，HSTU 相对标准 Transformer做了三个关键改动。理解这些改动的关键在于：每一个改动都对应一个” 标准Transformer 在推荐场景下的不适配”——HSTU不是为了改而改，而是因为 NLP里合理的默认假设到了推荐场景变成了阻碍。下面三个改动按重要性从高到低逐个来看。

改动一：训练目标从” 当前样本打分” 变成” 行为序列转导”

传统 ranker 的训练范式

传统 ranker 的训练范式是” 逐样本打分”：每条 $(u, i, \text{label})$样本独立贡献一个二分类 loss（点击 /不点击）。这背后的假设是” 每个样本独立、目标可以拆成逐条累加”。

HSTU 改成” 序列转导”

HSTU 论文标题里的 Sequential Transducers暗示了一个更根本的转变：训练目标从” 逐样本分类” 变成” 序列转导”。Transducer的意思是：输入一段历史行为序列，输出未来行为或目标 action的分布 —— 不是只服务某一个二分类 CTR目标，而是把多个推荐任务（点击、完播、点赞、转化……）统一成序列上的预测问题。

用具体例子看两者的差异

这里差异最容易被” 都用 CEloss” 这个表面相似性掩盖，所以用一个具体例子讲清楚。假设线上日志里有这样一条用户行为：

用户 U 在某次 session 里依次做了 4 个动作： 1. 看了篮球视频 A，完播2. 看了篮球视频 B，点赞 3. 看了美食视频 C，跳过 4. 看了篮球视频D，完播

Pointwise ranker 的做法 —— 把这条 session 拆成 4条独立样本：

样本	用户	item	label
1	U	篮球 A	1（完播）
2	U	篮球 B	1（点赞）
3	U	美食 C	0（跳过）
4	U	篮球 D	1（完播）

这 4 条样本在 batch 里可以打乱 —— 它们和” 用户 V 跳过游戏E” 这种样本地位完全相同。每条样本独立算一个 binary CE，加起来就是 batchloss：

\[\mathcal{L}_{\text{pointwise}} = -\big[\log \sigma(s(U, A)) + \log\sigma(s(U, B)) + \log(1 - \sigma(s(U, C))) + \log \sigma(s(U, D))\big]\]

历史序列（如果用了的话）只是作为特征进入 $s(U, \cdot)$，不参与 loss 构造。

HSTU 的做法 —— 整条 session作为一个训练样本，不拆。每个位置都贡献一个” 预测下一步” 的 loss 项：

位置 $t$	输入	预测目标	Loss 项
1	$x_1$（看篮球 A 完播）	$x_2$（看篮球 B 点赞）	$-\log p(x_2 \mid x_1)$
2	$x_1, x_2$	$x_3$（看美食 C 跳过）	$-\log p(x_3 \mid x_1, x_2)$
3	$x_1, x_2, x_3$	$x_4$（看篮球 D 完播）	$-\log p(x_4 \mid x_1, x_2,x_3)$

\[\mathcal{L}_{\text{HSTU}} = -\big[\log p(x_2 \mid x_1) + \log p(x_3 \midx_1, x_2) + \log p(x_4 \mid x_1, x_2, x_3)\big]\]

一条长度 $T$ 的序列贡献 $T-1$ 个 loss 项，每个位置都是一个” 给定前$t$ 步历史，预测第 $t+1$ 步” 的多分类任务。

这两种方法的三个差异对比如下

维度	Pointwise ranker	HSTU
样本能否打乱	可以，session 拆成独立样本	不可以，顺序是 loss 的一部分
Loss 形式	binary CE 逐条累加	多分类 CE 在每个位置算
一条 session 贡献多少 loss	$T$ 个（每个 $(u,i)$ 一个）	$T-1$个（每个位置预测下一步）
模型在预测什么	给 $(u, i)$ 打分	预测下一步 action
Item 之间是否独立	独立	通过 attention 互相影响

一个能体现差异的极端情况：假设用户 U 的 session 是” 看篮球 A → 看篮球A → 看篮球 A → 看篮球 A”（连续看 4 次同一个视频）。

Pointwise ranker：看到 4 条一模一样的样本 $(U, A, 1)$。模型只会学到” 用户 U 喜欢篮球A” 这个事实，重复 4 次的信号被压缩成” 对 A 的兴趣强度”
HSTU：看到一条序列 $(x_1, x_2, x_3, x_4)$ 都是” 看篮球A”。每个位置的 loss 都在问” 看完 A 之后下一步是什么”—— 模型会学到” 用户看完A 之后还会再看 A” 这个序列依赖关系，而不只是” 用户喜欢 A” 这个静态偏好

这种” 重复行为本身就是信号” 的特征，pointwise loss 完全捕捉不到，但HSTU 的 next-action loss 天然能捕捉 —— 这也是为什么 HSTU在长历史行为建模上比 pointwise ranker 更有优势。

工程上的两种用法

工程上这种统一范式可以落到两种用法：

候选打分：给定用户历史和候选 item，把候选 item作为未来 action 的一部分，预测它发生的概率或价值 —— 这是 HSTU替代传统精排的用法
召回侧 user 编码：用 HSTU 把用户历史编码成一个强user state 向量 $A_t$，再投影成 queryembedding，喂给 ANN 索引做检索 —— 这是 HSTU 替代传统双塔召回的用法

这里需要澄清一个容易混淆的点：HSTU 在召回侧并不” 生成 itemtoken”。它只是替代了双塔里 user 侧的 encoder——item 侧仍然是 hash ID+ embedding + ANN 索引。真正的” 生成式召回”（autoregressively 生成 itemtoken 序列）是 TIGER / OneRec 那条路，需要 semantic ID，HSTU官方实现不走这条路。这也是为什么 HSTU 论文标题里的 “Generative”指的是序列建模方式（把推荐重述成 next-action预测），不是指输出形态（生成 item token）—— 这两件事在TIGER / OneRec 里绑在一起，但在 HSTU 里是分开的。

所以 HSTU 既可以被描述成 generative recommender，也可以落在排序 /召回系统里使用。它真正替换的不是某一个模块名字，而是” 每个样本独立打分” 这个建模假设 —— 把推荐从” 判别问题” 重述成” 序列预测问题”。

HSTU 输出层结构示意

下面这张图总结了 HSTU 输出层在训练和推理两种场景下的工作方式：

需要强调的一个关键点：HSTU 的输出层不是 LLM 那种独立的 $W_{output}$矩阵，而是” 双塔式点积” 结构 ——user state $A_t$ 和 item embedding做点积得到分数，item embedding表在输入侧（编码历史序列）和输出侧（打分）共享同一份参数。这跟传统双塔召回模型的打分方式是一致的。

跟传统召回模型的相似性

说到这里会发现一个有意思的相似性：HSTU的训练范式跟传统双塔召回模型非常像 —— 都是 user embedding 和 itemembedding 做点积，都用 sampled softmax（正样本 +采样负样本）训练。DSSM、YoutubeDNN、MIND这些经典召回模型都是这个套路，HSTU 在输出层和 loss层面继承了这一范式。

真正的差异在 user encoder：传统双塔把用户历史行为 pool成一个向量（mean / sum）或浅层 MLP，HSTU则用序列模型显式建模行为之间的依赖。所以更准确的说法是：

HSTU ≈ 把双塔召回的 user encoder从” pooling / 浅层网络” 升级成” 序列模型”，但训练 loss（sampledsoftmax）和打分方式（点积）保留双塔召回的范式。

这也解释了为什么 HSTU能同时落在精排和召回两个场景 —— 它的输出层结构本来就是双塔式点积，跟召回的打分方式天然兼容；而序列建模带来的user state质量提升，又让它能替代传统精排。一个模型，两种用法，背后是同一套训练和打分范式。

改动二：pointwiseSiLU 替代 softmax attention

动机与 attention 基础

这项改动看起来只是换了一个激活函数，但它真正改变的是 attention的语义：标准 softmax attention 输出的是” 加权平均”，HSTU 的 pointwiseSiLU 输出的是” 证据累加”。

先解释一下 attention在做什么。一句话概括：当前要预测的位置发出一个 query $Q$，去历史里找相关信息；历史里每条行为都有个” 标签”$K$ 和一个” 内容” $V$（这条行为携带的信息）。$Q$ 和某个 $K$算点积，得到一个” 相关性分数”—— 分数越大说明这条历史和当前问询越相关。然后按相关性分数聚合所有$V$，就得到了 attention 的输出。

为了把数字算清楚，我们把向量都简化成 1维标量（实际模型里是多维向量，但 1 维足以说明问题）。

假设现在要预测” 用户对下一条篮球视频的兴趣”，所以问询 $Q$ 是” 篮球方向”。历史里有两类视频：

历史行为	类型	$K$（标签）	$V$（内容）	与 $Q$ 的相关性分数 $s = Q \cdot K$
第 1 条	篮球	1.0	1.0	1.0
第 2 条	篮球	1.0	1.0	1.0
第 3 条	篮球	1.0	1.0	1.0
第 4 条	美食	0.1	0.2	0.1

也就是说，篮球视频的相关性分数都是1.0（强相关），美食视频的相关性分数是 0.1（弱相关）。

接下来对比两个用户：用户 A 只有 1 条篮球历史，用户 B就是上面这张表（3 条篮球 + 1 条美食），用户 C 有 100 条篮球历史。

Softmax attention 怎么算

标准 Transformer 的 attention 是这样的：先把每个相关性分数过 $\exp$，再归一化成” 加起来等于1” 的权重，最后用这些权重对 $V$做加权平均。公式是：

\[A = \sum_j \mathrm{softmax}(s_j) \cdot V_j,\quad \mathrm{softmax}(s_j) =\frac{e^{s_j}}{\sum_k e^{s_k}}\]

用户 A（1 条篮球）：

分数：$[1.0]$
归一化权重：$[1.0]$（只有一个位置，权重自然是 1）
输出：$1.0 \times 1.0 =\mathbf{1.0}$

用户 B（3 条篮球 + 1 条美食）：

分数：$[1.0, 1.0, 1.0, 0.1]$
$\exp$ 后：$[2.72, 2.72, 2.72, 1.11]$
总和：$2.72 \times 3 + 1.11 =9.27$
归一化权重：$[0.294, 0.294, 0.294,0.120]$
输出：$0.294 \times 1.0 + 0.294 \times1.0 + 0.294 \times 1.0 + 0.120 \times 0.2 = 0.882 + 0.024 =\mathbf{0.906}$

注意这里发生了什么：用户 B 比 A 多看了 2 条篮球，但输出反而从 1.0跌到了 0.906—— 因为新增的 3条篮球要和那条美食视频争抢同一个固定的权重预算1，篮球每条只分到 0.294，把总权重拉低了。

用户 C（100 条篮球）：

分数都是 1.0
归一化权重：每条 $1/100$
输出：$100 \times (1/100) \times 1.0 =\mathbf{1.0}$

把三个结果并排放：

用户	历史	Softmax 输出
A	1 条篮球	1.0
B	3 篮球 + 1 美食	0.906
C	100 条篮球	1.0

问题立刻浮现：用户 A 只看了 1 条篮球，用户 C 看了 100条 —— 两者的兴趣强度显然差 100 倍，但 softmax给出的输出几乎完全一样。softmax只能表达” 兴趣方向是什么”，表达不了” 兴趣强度有多大”。原因就是那个归一化：所有权重加起来被强制锁死成1，无论历史里有 1 条还是 1000 条，注意力总量都固定。

Pointwise SiLU attention 怎么算

HSTU的做法是：不要归一化，让每条历史独立贡献一份证据，最后直接相加。公式是：

\[A_i = \sum_{j \le i} \mathrm{SiLU}(s_j) \cdot V_j,\quad \mathrm{SiLU}(x)= x \cdot \sigma(x) = \frac{x}{1 + e^{-x}}\]

这里 $\mathrm{SiLU}$（也叫swish）是一个激活函数，它的形状是：输入 $x$越大、输出越大；输入很小或为负时输出接近 0。它替代了 softmax的归一化，但保留了” 对相关性分数做非线性变换” 这个作用。

先算两个要用到的 SiLU 值：

$\mathrm{SiLU}(1.0) = 1.0 \times\sigma(1.0) = 1.0 \times 0.731 = 0.731$
$\mathrm{SiLU}(0.1) = 0.1 \times\sigma(0.1) = 0.1 \times 0.525 = 0.0525$

用户 A（1 条篮球）：

输出：$\mathrm{SiLU}(1.0) \times 1.0 =0.731 \times 1.0 = \mathbf{0.73}$

用户 B（3 条篮球 + 1 条美食）：

篮球贡献：$3 \times \mathrm{SiLU}(1.0)\times 1.0 = 3 \times 0.731 = 2.193$
美食贡献：$\mathrm{SiLU}(0.1) \times 0.2= 0.0525 \times 0.2 = 0.0105$
输出：$2.193 + 0.0105 =\mathbf{2.20}$

用户 C（100 条篮球）：

输出：$100 \times \mathrm{SiLU}(1.0)\times 1.0 = 100 \times 0.731 = \mathbf{73.1}$

三个结果并排放：

用户	历史	Softmax 输出	SiLU 输出
A	1 条篮球	1.0	0.73
B	3 篮球 + 1 美食	0.906	2.20
C	100 条篮球	1.0	73.1

差别一目了然：

softmax 下，用户 A 和用户 C 输出几乎一样（1.0 vs1.0），看不出强度差别
SiLU 下，用户 C 的输出是用户 A 的 100 倍（73.1 vs0.73），直接反映了” 看了 100 条” 和” 看了 1 条” 的兴趣强度差

这恰好对应推荐场景最关心的信号 ——“用户对篮球有多感兴趣” 本身就藏在” 互动了几次” 这个绝对数量里。

还原成真实模型里的多维向量形式

上面的例子为了能跟着算，把向量简化成了 1 维标量。真实模型里 $Q, K, V$都是多维向量，但核心逻辑完全一样。先把几个容易被忽略的 transformer基础讲清楚，免得后面的公式看不懂。

第一，$Q, K, V$不是直接训练的参数，而是输入经过投影后的中间结果。HSTU 在第 $t$ 步的输入是一个事件向量 $x_t = \mathrm{Embed}(i_t, a_t, c_t, \Delta t_t,\dots)$—— 它描述的是” 用户在第 $t$ 步对哪个 item做了什么动作、在什么场景下、距上次多久” 这整个事件。然后用三个共享的可训练权重矩阵$W_Q, W_K, W_V$ 把 $x_t$ 投影成三种角色：

\[q_t = W_q \tilde{x}_t,\quad k_t = W_k \tilde{x}_t,\quad v_t = W_v\tilde{x}_t\]

序列里所有位置共享同一组 $W_Q, W_K,W_V$—— 区别只在于输入 $x_t$不同（篮球事件 vs 美食事件），所以投影出的 $K$ 不同。篮球视频在例子里的 $K=1.0$、美食视频 $K=0.1$，可以理解为” 学好的 $W_K$把这两类事件投影到了不同的标签位置”。

第二，attention 真正做的事是把历史事件聚合成” 用户状态”。HSTU 在第$t$ 步用 attention 把 $x_1, \dots, x_t$这串历史事件聚合成一个隐状态 $A_t$—— 这才是” 用户经历 $t$ 步行为后的状态”，而 $x_t$ 本身只是第 $t$步那条事件。整个序列建模就是” 基于 $x_1, \dots, x_t$ 算出状态 $A_t$，再基于 $A_t$ 预测第 $t+1$步最可能发生什么行为” 的循环。

理解了这两点，再看两个公式的差异就清楚了。标准 Transformer 的attention：

\[A_i = \sum_{j \le i} \mathrm{softmax}(q_i^\top k_j) \cdot v_j,\quad\sum_j \alpha_{ij} = 1\]

HSTU 的 pointwise normalized-less attention：

\[A_i = \sum_{j \le i} \phi(q_i^\top k_j + b_{ij}) \cdot v_j,\quad \phi =\mathrm{SiLU}\]

逐符号定义：

$q_i, k_j, v_j$：query / key /value 向量，分别来自第 $i$ 个和第$j$ 个位置（由上面的 $W_Q, W_K, W_V$ 投影得到）
$b_{ij}$：可选的位置 / 时间 /相对顺序 bias，用来表达” 多久以前发生的行为” 和” 当前行为” 的关系
$\phi$：激活函数。HSTU 用SiLU（也叫 swish），不做 softmax 归一化
$A_i$：第 $i$ 个位置从历史行为里聚合到的隐状态
$j \le i$：因果mask，只允许当前位置看见过去，不能偷看未来

两个公式只差一个 softmax，但语义完全不同：softmax输出” 加权平均”，SiLU输出” 证据累加”。用一个粗糙的类比总结这个差别：

softmax attention 像在问：“这 100 条历史里，哪几条最重要？请把总权重1 分给它们。”
pointwise SiLU attention像在问：“每一条历史分别能提供多少证据？有用的就加上，没用的就少加或不加。”

为什么这对推荐场景特别重要，对 NLP 却没那么重要？这其实可以从 softmax归一化在 NLP 里能成立的前提反推。softmax 把权重归一化成1，本质上是假设” 历史位置之间是竞争关系”—— 一句话里的 token是在有限上下文里互相解释，“哪个 token更重要” 是合理的问题，归一化让模型能聚焦最相关的几条。但推荐行为序列完全不一样 —— 重复次数、连续互动、兴趣强度本身就是特征，行为之间不该争抢同一个注意力预算。HSTU换成 pointwise SiLU，本质上就是承认” 在推荐场景下，加权平均这个 NLP里合理的语义反而是错的，应该换成证据累加”。HSTU论文在合成数据上观察到，这一差异能带来高达 44.7% 的 NDCG 差距。

改动三：保留hash / sparse 体系，不强依赖 semantic ID

这一点正是改动一提到的观点，也是会非常容易被误解的点

TIGER / OneRec 这条生成式路线高度依赖 semantic ID—— 因为它们要” 生成item”，必须先把 item 变成可生成的 token 序列。一个常见的误解是” HSTU既然是 generative recommender，也应该依赖 semantic ID”。但 HSTU的官方实现恰恰相反，大部分还在用 hash ID + sparse featureembedding。

为什么 HSTU 可以不依赖 semantic ID？

因为 HSTU 挑战的是 cascade 的假设 B 和 C里它真正解决的那一部分，而不是全部。具体说：

挑战 B1（pointwise 独立打分）：HSTU 用序列建模替代pointwise 打分 —— 训练目标从” 逐样本分类” 变成” 序列转导”，item之间通过历史序列隐式建模，不再是孤立的 $(u,i)$ 评分
挑战 C（没有 scaling law）：HSTU 用 pointwise SiLUattention + 序列转导训练目标 + 工程配套优化，让推荐模型在三个数量级compute 上遵循 power-law scaling，第一次系统性验证了推荐场景的 scalinglaw
不挑战 A（item 是离散原子）：HSTU 官方实现里 item仍然是 hash ID + sparse embedding，没有换成 semantic ID
不挑战 B2（多步级联能近似全局最优）：HSTU仍然落在级联系统里当精排或召回用，没有把召回/精排/重排合并成一个端到端模型

最后一点容易被误解。HSTU 论文标题里的 “Generative”指的是建模方式上的生成式（把推荐重述成 next-action预测），不是输出形态上的生成式（自回归生成 itemtoken）。前者是 HSTU 做的事 —— 用序列建模替代独立打分；后者是 TIGER /OneRec 做的事 ——decode 出 semantic ID token 序列再映射回真实 item。HSTU官方实现不生成 item token，所以仍然依赖 ANN检索，仍然落在级联系统里使用。

真正挑战 B2（端到端替代 cascade）的是OneRec—— 它用一个 encoder-decoder 一口气生成整张list，把召回 + 排序 + slate 统一在一个生成框架里。这一点后面” GR在召回/排序/列表生成的不同落地形态” 那张对照表会看得更清楚：HSTU归到” 第一层精排”，OneRec 归到” 端到端”。

所以 HSTU 的核心是” 在行为序列上做可扩展的序列建模”，不是” 重新设计item 表征”。hash ID 在 HSTU 里只是 action token的一种 —— 只要行为序列建模能力够强，模型自己会学出 item之间的关系，不一定非要换成 semantic ID。

HSTU 和 semantic ID 是正交的

所以 HSTU 和 semantic ID 是正交的两件事：

如果业务的主要瓶颈是冷启、长尾、item表征无结构，semantic ID 更直接 —— 它能给新 item一个有结构的位置
如果业务的主要瓶颈是行为序列建模能力和模型scaling，HSTU 更直接 —— 它解决的是 backbone 能力，不是 item表征
如果两者都成立，理论上可以把 semantic ID 作为 item 表征的一部分喂给HSTU，但这只是锦上添花，不是 HSTU 成立的前提

这一点对实际落地很重要：不需要先做完 semantic ID 才能尝试HSTU，两件事可以独立推进。

路线二：端到端生成式（OneRec/ TIGER 系）

路线一是” 用推荐数据训 backbone，但不生成 item token”——HSTU落在精排 / 召回，仍然是级联系统的一个模块。路线二则更激进：用推荐数据从头训一个encoder-decoder，自回归生成 item token（semantic ID），把召回 + 排序 + slate统一在一个生成框架里，目标是端到端替代 cascade。

代表工作是 OneRec(arXiv:2502.18965) 和 TIGER(arXiv:2305.05065)。两者架构思路相近，但落地程度完全不同 ——TIGER停在学术验证阶段，OneRec 已在快手主站大规模上线（完整上线数据见 OneRec Technical Report,arXiv:2506.13695）。

OneRec 的一些核心改动如下

encoder-decoder 结构：encoder处理用户历史序列，decoder 自回归生成下一个（或下一组）item 的 semanticID token
session-wise list generation：不是逐个 item预测，而是一次性生成整个 session 的 item 列表，让模型自己学 item之间的相对关系和顺序
强依赖 semantic ID：因为要” 生成 item”，必须先把item 表达成可生成的 token 序列（RQ - VAE semantic ID）—— 这跟 HSTU“不强依赖 semantic ID” 形成对比
MoE 扩参：OneRec 的 decoder FFN 用 MoE，让模型从0.015B 扩到 2.633B 参数仍遵循 scaling law

下图展示了 OneRec 这类端到端生成式推荐的核心流程：

整体分为五步（工程细节留到后面” 解码与推理” 一节展开）：

item → semantic ID（离线一次性）：每个 item 通过RQ - VAE 编码成一串 semantic ID token，相似 item 共享前缀。这一步是后续constrained decoding 能高效裁剪路径的基础
用户历史 → encoder隐状态（在线，每请求一次）：用户历史序列（每个历史 item 也用semantic ID 表示）输入 encoder 得到隐状态 $H$。这一步跟路线一 HSTU编码用户状态一样，区别在下一步 ——HSTU 用 $H$ 对候选打分，OneRec 用 $H$ 驱动 decoder 生成
decoder 自回归生成 semanticID（session-wise）：decoder 基于 $H$，以 [BOS]起始，自回归生成一个完整 session（5-10 个 item）的 semantic ID序列。这是路线二跟路线一最关键的区别 ——HSTU候选由上游给定只负责打分，OneRec 模型自己生成整张列表
constrained decoding 保证合法性：decoder 裸生成的token 序列可能对应不到任何真实 item，工程上用 Trie-based constraineddecoding 保证只生成合法 semantic ID
semantic ID → 真实 item：合法 semantic ID通过映射表查回真实 item，按生成顺序组成最终推荐列表

训练目标

路线二的训练目标是 next-token CE loss，对应” 给定历史和已生成的token，预测下一个 semantic ID token”：

\[\mathcal{L}_{\text{NTP}} = -\sum_{i=1}^{m} \sum_{j=0}^{L-1} \logP(c^{(j)}_i \mid [\text{BOS}], c^{(1)}_1, \dots, c^{(j-1)}_i; \Theta)\]

其中 $m$ 是 session 内 item数量，$L$ 是每个 item 的 semantic ID层数，$c^{(j)}_i$ 是第 $i$ 个 item 的第 $j$ 层 codebook 索引。整个 session的生成概率可以分解为（TIGER 的公式）：

\[P(\text{session} \mid \text{history}) = \prod_{i=1}^{m}\prod_{j=0}^{L-1} P(c^{(j)}_i \mid c^{(

对齐阶段（IPA）不是只优化 DPO loss，而是把 NTP loss 和 DPO loss加权相加作为联合训练目标（详见后面” 训练目标：从 next-token到偏好对齐” 节）：

\[\mathcal{L} = \mathcal{L}_{\text{NTP}} + \lambda\mathcal{L}_{\text{DPO}}\]

路线二最独特的不是” 生成 item” 本身（TIGER 也生成 item），而是session-wise list generation—— 一次生成整个 session而不是单个 item。这带来两个好处：

建模 item 之间的相对关系和顺序：传统pointwise/next-item 预测只能问” 下一个 item 是什么”，session-wise能问” 这一整屏应该推什么、先后顺序如何”，让模型自己学 list内部的依赖关系（比如篮球视频之后推体育周边比推美食更合理）
天然统一了召回 + 排序 + slate：传统 cascade里” 召回拉候选 → 精排打分 → 重排出 slate” 三步，在 session-wise generation里被压缩成” decoder 一次性生成整个 slate” 一步。这是路线二能挑战假设B2（多步级联能近似全局最优）的根本原因 —— 它直接把多步级联替换成一步生成

自回归 decode 整张列表的延迟挑战非常严峻 ——beam search、constraineddecoding、KV cache、MoE 稀疏激活等工程优化是 OneRec能上线的关键。这些工程细节留到后面” 解码与推理” 一节统一展开，那里会以OneRec 为具体例子把 constrained decoding、beamsearch、工业延迟约束这些通用机制串起来。

路线一和路线二都用推荐数据从头训，但两者在” 输出形态” 上完全不同：

维度	路线一（HSTU）	路线二（OneRec）
是否生成 item token	否（双塔式点积打分）	是（自回归生成 semantic ID）
是否依赖 semantic ID	不强依赖（hash ID 也行）	强依赖（必须先生成 token）
落在级联的哪一层	精排 / 召回（替换某一层）	端到端（统一召回 + 排序 + slate）
挑战的 cascade 假设	B1（pointwise 独立打分）+ C（scaling law）	B2（多步级联能近似全局最优）
推理方式	历史编码一次 + 候选并行打分	自回归 decode 整张列表
候选池保证	上游给定 / ANN 索引	constrained decoding + Trie 裁剪
一次请求产出	top-N 候选打分	一整张 session 列表

这个差异决定了两者落地的难度 ——HSTU落在级联里某一层，工程上可以渐进替换；OneRec 是端到端替代cascade，工程改造范围大得多，但天花板也高得多。

OneRec 是目前公开资料中最完整、最典型的端到端 GR 替代 cascade工业案例之一。原始论文 OneRec(arXiv:2502.18965) 只报告了主站 watch-time +1.6%一个上线数字，更完整的上线数据来自后续的 OneRec Technical Report(arXiv:2506.13695)：

快手主站 + 极速版短视频主场景：承担约 25% QPS；App Stay Time 主站+0.54%、极速版 +1.24%（OneRec + RM Selection vs 传统 cascade）；LT7 主站+0.05%、极速版 +0.08%。论文注明在快手 0.1% 的 App Stay Time 提升、0.01%的 LT7 提升已算统计显著
本地生活场景：GMV +21.01%，订单量 +17.89%，付费用户+18.58%，新客获取效率 +23.02%，已 100% QPS 全量切换（OneLoc 系列工作，见arXiv:2508.14646）
运营成本（OPEX）仅为传统方案的 10.6%

但路线二也有其局限的地方

独立验证仍然有限：OneRec / OneLoc / OneRec V2都来自快手技术谱系，公开资料已经覆盖短视频、本地生活等多个场景，但还缺少第二家公司在主流推荐场景里的同等级端到端验证。相比之下路线一（HSTU）有Meta（HSTU 多产品上线）+ 美团 MTGR（arXiv:2505.18654，MTGR-large已全量部署到美团外卖推荐主流量）两家独立上线。
改造范围大：端到端替代 cascade意味着召回、排序、重排整个链路都要重构，工程改造比 HSTU替换某一层大得多。
推理延迟挑战：自回归 decode整张列表天然有劣势，OneRec V2 的 Lazy Decoder-Only架构是这个方向最新的工程进展。

OneRec 的详细 RL 对齐方法（Iterative PreferenceAlignment）后面会单独展开，这里只讨论它在三条路线里的定位。

路线三：直接复用通用 LLM

这条路的核心论点是：通用 LLM已经学到了丰富的世界知识和文本理解能力，把推荐改写成 prompt /instruction 任务即可，不需要从头训一个推荐基础模型。

这条路按时间顺序看三篇代表工作，正好能看出” 让 LLM做推荐” 的演进逻辑：从一开始的” 让 LLM 生成一切”，逐渐退到” 让 LLM只做精排打分”—— 每一退都是被推荐场景的现实约束逼出来的。

P5 (RecSys 2022, arXiv:2203.13366)：最早的全面文本化尝试

P5 的思路是” 把推荐全面语言化”—— 基于 T5 encoder-decoder（223M参数），把所有推荐数据（user-item 交互、用户描述、item元数据、评论）都转成文本prompt，然后用一个共享的语言建模目标在多个任务上预训练。P5统一了五类任务：

评分预测（rating prediction）：给 user-item 对预测评分
序列推荐（sequential recommendation）：给历史交互序列预测下一个item
解释生成（explanation generation）：生成推荐理由文本
评论摘要（review summarization）：把长评论总结成标题
评论偏好预测（review preference prediction）：从评论预测评分

P5 最关键的设计选择是：item ID 被拆成 sub-wordtoken—— 比如 item_7391 被 tokenize 成item、_、7391 三个子词。这意味着item 可以通过 decoder 自回归生成，跟 LLM 生成自然语言完全一样。P5的卖点是” 一个模型多任务 + zero-shot 泛化”—— 预训练后能泛化到没见过的prompt 和新 item。

但 P5 有一个明显问题：item ID 是当文本 token生成的，没有任何机制保证生成的 ID 落在合法 item池里。模型可能生成一个根本不存在的item_99999，也可能生成一个语义上合理但 item 池里没有的ID。这是把推荐当 NLP 做的必然代价 ——LLM 的词表是开放的，但推荐场景的 item池是封闭的。

BIGRec (arXiv:2308.08434)：承认生成结果需要grounding

BIGRec 针对 P5 留下的” 生成 ID 不合法” 问题提出了 bi-step grounding范式：

Step 1（grounding）：fine-tune LLM 让它生成 item描述相关的 token，把 LLM 从语言空间” 接地” 到推荐空间
Step 2（matching）：用 LLM 的 latentrepresentation，把生成的 token 映射到最接近的合法 item

也就是说，BIGRec 不再指望 LLM 生成的 token 序列本身就是合法 itemID，而是把它当成一个” 语义锚点”，再用最近邻搜索映射回合法 item 池。这跟HSTU 那条路里” 输出层是双塔式点积 + ANN检索” 的处理思路异曲同工 —— 都是承认生成端无法直接保证合法性，需要后处理映射。

但 BIGRec 论文还揭示了一个更深层的发现：纯 LLM路线学习协同信号的效率和稳定性仍然不足。论文观察到，增加训练样本数量给BIGRec 带来的边际收益很有限 —— 因为 LLM的强语义先验会压制对统计信息（如热度、协同过滤信号）的学习。这一点对路线三的整体判断很关键：LLM预训练里学到的是” 语言里的语义关联”，不是” 用户行为里的协同关联”—— 前者是语义信号，后者是统计信号，两者并不等价。

LlamaRec (PGAI@CIKM 2023, arXiv:2311.02089)：干脆放弃生成item，只让 LLM 做精排

LlamaRec 的思路是：既然 LLM 生成 item有合法性问题和效率问题，那干脆不让 LLM 生成item，只让它做精排打分。具体是两阶段：

Stage1（召回）：用传统序列模型（SASRec / LRURec）做召回，拉回候选 item集合
Stage 2（精排）：把用户历史和候选 item都转成文本喂给 LLM，用 verbalizer 把 LLM 输出 logits 直接映射成候选 item的概率分布

关键是 verbalizer 这个技巧 —— 把每个候选 item 对应到LLM 词表里的一个特定 token（或一组 token），一次前向就能读出所有候选的logit，不需要 autoregressive 生成。LlamaRec 用 LLaMA-2-7b + LoRA微调，verbalizer 让它在一次前向里完成所有候选打分，绕开了 LLM 自回归decode 慢的问题。

这个设计很巧妙：它把 LLM的输出层从” 生成器” 改成了” 打分器”——LLM 不再生成item，只是用它的语义理解能力对候选 item 评分。这跟 HSTU的” 输出层是双塔式点积” 有异曲同工之处：两者都是” 用模型编码出 query / userstate，再对候选 item 打分”，只是 HSTU 的 backbone 是序列模型、LlamaRec的 backbone 是 LLM。

三篇论文反映的演进逻辑

把三篇放在一起看，路线三的演进方向非常清晰：

论文	年份	LLM 的角色	如何保证 item 合法性
P5	2022	生成 item ID	不保证（生成 token 可能不是合法 ID）
BIGRec	2023	生成 item 描述 token	后处理映射（latent 最近邻）
LlamaRec	2023	对候选 item 打分	候选由上游给定（LLM 不负责生成）

演进方向是：从” 让 LLM 生成 item” 逐渐退到” 让 LLM做打分”。每一退都是被推荐场景的现实约束逼出来的：

P5 不保证合法性 → BIGRec 加 grounding 后处理
BIGRec 的 grounding 仍然慢（要生成 + 映射），且纯 LLM路线学习协同信号的效率不足 → LlamaRec 干脆放弃生成，只做打分
最终 LlamaRec 退到了” LLM 做精排” 的位置 —— 跟 HSTU落在精排场景的位置重合，但 backbone 换成了 LLM

这个演进也解释了为什么路线三目前工业落地很少 —— 退到 LlamaRec这一格，LLM相比传统精排的优势只剩” 语义理解能力”，但在推理延迟、行为信号建模、训练成本上都处于劣势。LLM的语义理解能力在” 长尾、冷启、对话式” 这些子场景有局部价值，但在” 行为数据极大、延迟要求严苛” 的主流推荐场景，这个优势不足以弥补延迟和成本的劣势。

两个工业延伸工作：HLLM 和 URM

P5/BIGRec/LlamaRec都是学术工作，但路线三在工业侧有两个延伸值得单独提一下 —— 它们都是” 用 LLM思想做推荐”，但走了跟纯 LLM-as-Recommender 不同的路：

HLLM（ByteDance, arXiv:2409.12740）：用两层LLM 把” item 内容理解” 和” 用户行为建模” 解耦 ——Item LLM 负责把 item的文本描述压成 content embedding，User LLM 负责在这些 embedding上做行为建模。这种解耦在” item内容信息丰富、行为信号相对稀疏” 的场景特别适合（比如长视频、电商商品），对冷启和长尾的提升非常显著 —— 这部分场景正是LLM 的语义理解能力能真正发挥价值的地方
URM（Alibaba, arXiv:2502.03041）：把召回看成一个” 通用任务”—— 同一个模型既可以做multi-scenario 召回、又可以做 multi-objective召回、还可以做长尾召回。multi-query representation让模型一次推理产出多组 query embedding，每个 query 对应不同的目标 /场景。这其实是把 LLM 的 “instruction-following” 思想搬到推荐召回上

这两个工作的共同特点是：没有让 LLM 直接生成 itemtoken，而是用 LLM 思想改造推荐系统内部某个模块。这比 P5那条” 把推荐全面语言化” 的路子工业落地容易得多 —— 也是路线三里少数有公开工业A / B 或测试证据的方向。

三条路线的差异

很多解读把 HSTU、OneRec、LLM-as-Recommender当作” 类似的事情”，但仔细看一下就会发现，它们的起点、复用什么、适合什么场景，都完全不同：

维度	路线一（HSTU）	路线二（OneRec）	路线三（LLM-as-Recommender）
起点	从推荐数据从头训	从推荐数据从头训 encoder-decoder	从预训练 LLM fine-tune
复用什么	scaling law 本身	scaling law + semantic ID + 端到端	LLM 的世界知识 + 文本理解
是否生成 item token	否（双塔式点积打分）	是（自回归生成 semantic ID）	部分生成（P5 / BIGRec），部分打分（LlamaRec）
关键信号	行为序列	行为序列 + item 表征结构	文本描述
挑战的假设	B1（pointwise）+ C（scaling law）	B2（多步级联）+ C（scaling law）	主要是 B1（用 LLM 替代打分）
适合场景	行为数据极大的 feed / 短视频	端到端统一召回 + 排序 + slate	长尾、冷启、对话式
推理延迟	中（特化架构可深度优化）	高（自回归 decode 整张列表）	高（通用 LLM decode 慢）
工业落地证据	Meta（HSTU 多产品上线）+ 美团 MTGR（arXiv:2505.18654）	快手主站 + 极速版上线	主流场景几乎没有，局部场景有
上线难度	高，但已被 Meta 验证可行	极高，工程改造范围大	高，工业案例非常少
工业证据强度	已验证（范式级贡献）	端到端证据较完整，但主要来自同一技术谱系	学术有效，工业未验证
主要瓶颈	暂无明显瓶颈，Meta（HSTU）+ 美团（MTGR）两家独立大厂验证	改造范围大、推理延迟严峻，公开证据主要来自同一技术谱系	行为信号注入不足 +推理延迟难压到几十毫秒；仅长尾/冷启/对话式有局部价值

解码与推理：让生成的token 落到真实 item

核心问题：生成的 token 序列可能根本对应不到任何真实item

一个自回归模型采样出的 token 序列，在普通 LLM场景下可以是任意自然语言。但在 GR 里，生成的 semantic ID必须能映射回一个真实存在、当前合法、当前未屏蔽的item。否则推荐结果就是空气。

工程上解决这个问题有几条标准做法。下面以 OneRec为具体例子把这套机制串起来 ——TIGER 的机制基本相同，只是没有上工业。

Beam search：避免贪心把高概率路径过早丢掉

最基础的做法。贪心 decode 每步选概率最高的 token，但 semantic ID 是多token 序列 —— 某条路径第一步概率高但下一步无路可走（剩下 token都不合法），贪心就会卡死。beam search 同时维持 top-k条候选路径并行扩展，最后从完整路径里选总概率最高的。

OneRec 的 beam size 取到 128 量级 —— 这意味着每一步要同时维护 128条路径的 KV cache 和概率，对显存和带宽都是压力。这个数字直接决定了decode 的延迟下限。

Constrained / prefix-aware decoding：在合法集合上做softmax

beam search 解决的是” 挑哪条路径”，constrained decoding解决的是” 每一步只在合法 token 上做 softmax”。每一步 decode 时，先mask 掉所有非法 token，再做 softmax 和采样，从源头杜绝生成空气item。

semantic ID 的层级结构让这一步天然适配 Trie：

第一层 token 只能在” 训练集里出现过的第一层 codebook 索引” 里选
第二层 token 只能在” 给定第一层 token后，训练集里出现过的第二层组合” 里选
以此类推

也就是说，semantic ID 的前缀就能裁剪掉绝大多数无效路径。OneRec把所有合法 semantic ID 预先组织成一棵 Trie，decode 时每走一步就在 Trie上推进一个节点，下一步的合法 token 集合就是这个节点的子节点 key集合 —— 一次 mask 操作就能完成约束。

这一点是 TIGER 和 OneRec 都采用的关键工程技巧，也是路线二” 强依赖semantic ID” 的工程原因 —— 如果没有 RQ - VAE 把 item 编码成有层级前缀的semantic ID，constrained decoding 就退化成对全部 item ID 做mask，失去前缀裁剪的效率优势。

与 ANN 的关系

这里有一个常见的误解需要澄清：GR 的生成式召回不是” 替代了ANN”，更准确的说法是”用 transformer memory 替代了 ANN索引”。也就是说，召回这件事变成了”模型参数本身就是index”，而不是” 模型 + 外部index”。这个区别在工程上很重要：模型重训意味着 index重训，模型上线意味着 index 上线，两者不再可以独立部署。

工业延迟约束：自回归 decode 的最大瓶颈

传统精排在工业上几十毫秒结束战斗，自回归 decode 天然有劣势 —— 每一个token 都要走一次前向。一个 session 要生成 5-10 个 item，每个 item 假设3-4 层 semantic ID token，总共就是 15-40 步前向，再叠加 beam size 128的并行扩展，naive 实现的延迟完全不可用。

OneRec 能上线，靠的是几项工程优化叠加把延迟压下来：

KV cache：encoder 的隐状态和已生成 token 的 K / V缓存复用，避免每步重复计算历史
MoE 稀疏激活：decoder FFN 用 MoE，每个 token只激活少量 expert，实际算量远小于 dense 模型 —— 这让模型能扩到 2.6B参数仍遵循 scaling law，又不会让单步延迟爆炸
float16 / 低精度推理：进一步压显存和带宽

OneRec V2（arXiv:2508.20900）的 LazyDecoder-Only 架构号称把总计算减少 94%、训练资源减少 90%、模型 scale 到8B 参数，是这个方向最新的工程进展 —— 它的核心思路是延迟部分 token的解码，只在真正需要时才走完整 decoder，减少无效计算。

constrained decoding 和 transformer-as-index这两件事本身已经被多家工业系统验证可行。但相比 cascade 范式下成熟的 ANN+ 精排链路，自回归 decode的延迟开销仍然显著更高。这是为什么直到现在，端到端 GR主要在 “延迟相对宽松” 的内容 feed场景上线，而搜索、广告这类对延迟极敏感的场景几乎没有看到。

训练目标：从 next-token到偏好对齐

前面三大支柱讲的” 生成式架构” 用的是 next-token cross-entropy训练。但这个 loss 天然只能优化” 下一个用户最可能交互的 item”—— 这只是一个surrogate，不是推荐真正关心的目标。这一节单独讲 next-token loss之外的对齐机制。

为什么单纯 next-token loss不够

next-token loss 不解决的问题有四类：

多目标trade-off：CTR、watch-time、转化、留存之间的权衡，next-token没法显式表达
长期价值：session深度、次日留存、复购，这些信号天然延迟、稀疏
业务约束：广告load、营销感打散、品类多样性，这些硬约束不在生成模型的视野内
exploration：模型只见过历史日志里的 token组合，对没见过的组合没有探索动机

在 LLM 领域，这些问题对应的解决方案就是 RLHF（Reinforcement Learningfrom Human Feedback）。GR 沿用了 RLHF 的思想，但具体做法和 LLM有几个关键差别。需要预先指出的是，RL对齐能解决的只是软偏好类问题（多目标隐式权衡、长期价值、exploration）；至于” 业务约束” 这一类 ——pacing、load上限、score shading、calibration 这类硬约束和在线控制问题 ——next-token范式天然不擅长，RL 也解不了，仍然要靠传统控制方法兜底（详见后面” GR 在cascade 各层的落地形态” 一节关于第二层混排的讨论）。

OneRec 的 IterativePreference Alignment

OneRec(arXiv:2502.18965) 是目前 GR 领域 RL对齐最有代表性的工业方案。它的做法分五步：

第一步：训一个 reward model $R_\phi$

输入是 session 级别的生成序列（也就是一段被推荐给用户的 item列表），输出是一个标量 reward。reward的训练标签来自多目标业务结果 ——watch-time、互动、转化等真实指标。

第二步：用当前 policy 生成候选 session

用当前的 GR 模型（policy $\pi_\theta$）通过 beam search 生成 $K$ 条候选 session $\{\pi^{(1)}, \dots, \pi^{(K)}\}$。这里的$\pi$ 指代一条完整的推荐session（不是数学符号 $\pi_\theta$ 的$\pi$），上下文会区分清楚。

第三步：构造 preference pair

用 reward model $R_\phi$给每条候选打分，把 reward 最高的当 chosen ($\pi^+$)，reward 最低的当 rejected ($\pi^-$)。

第四步：NTP + DPO 联合对齐

OneRec 在 IPA 阶段不是只用 DPO loss，而是把next-token loss 和 DPO loss 加权相加作为联合训练目标：

\[\mathcal{L} = \mathcal{L}_{\mathrm{NTP}} + \lambda\mathcal{L}_{\mathrm{DPO}}\]

其中 DPO loss 的具体形式是：

逐符号定义：

$\pi_\theta$：当前 policy（GR模型）
$\pi_{\mathrm{ref}}$：参考policy——OneRec 里是上一轮迭代的 model $M_t$（不是 SFT 阶段 frozen 的checkpoint），每轮迭代都会更新
$\pi^+, \pi^-$：reward 高 /低的候选 session
$\beta$：温度系数，控制对齐强度。$\beta$ 越大，policy 越紧贴偏好；$\beta$ 越小，policy 越保守
$\sigma$：sigmoid 函数
$\lambda$：DPO loss 权重。论文里DPO 样本相对 NTP 样本占比约 1%，$\lambda$ 用来平衡两类 loss 的量纲

这里有两个关键点需要强调：

NTP loss 始终保留：即使在 IPA 阶段，next-token loss也没有丢掉 —— 它跟 DPO loss 一起作为联合 loss 训练，充当 anchor 防止policy 漂得太远。如果只留 DPO loss、丢掉 NTP loss，policy 很快会被reward model 的偏差带跑偏
reference policy 是动态的：跟 LLM RLHF 里” SFTcheckpoint frozen 当 reference” 的做法不同，OneRec 的 $\pi_{\mathrm{ref}}$ 是上一轮 model $M_t$，每轮迭代都会更新 —— 这是” iterative” 的另一层含义

通俗一点说，这个联合 loss 想做的事情是：让 policy 输出 $\pi^+$ 的相对概率比 $\pi^-$ 更高（DPO 部分），同时不能离参考policy 太远（$\beta$项），还要继续做好 next-token 预测（NTP 部分）。

第五步：迭代

用 $\mathcal{L} =\mathcal{L}_{\mathrm{NTP}} + \lambda \mathcal{L}_{\mathrm{DPO}}$联合训练得到 $M_{t+1}$ 后，再以 $M_{t+1}$ 为新 policy 重新生成候选、重新用reward model 打分、重新构造 preference pair、再联合训练 $M_{t+2}$。每一轮迭代里 NTP loss 都跟 DPOloss 一起参与训练，不是切到对齐阶段就丢掉。这个迭代过程是 OneRec名字里” Iterative Preference Alignment” 的来源。

整个训练流程总结一下：先用纯 NTP loss 训一个 seed model（SFT 阶段）→进入 IPA 阶段，每轮迭代用 $\mathcal{L}_{\mathrm{NTP}} + \lambda\mathcal{L}_{\mathrm{DPO}}$ 联合训练，reference policy 是上一轮model（动态变化）。

GR 的 RL 和 LLM 的 RLHF有什么本质区别

把 OneRec 和 LLM 的 RLHF 放在一起对比，最关键的差别是preference pair 的来源：

LLM 的 RLHF 里，preference pair是人类标注员逐条比较得到的。NLP的输出空间是自然语言，标注成本可控。

GR 里没人愿意逐条比较推荐列表 —— 每次推荐都是几条到几十条item，标注一个 session 就要几分钟，规模化做不了。所以 GR 的preference pair 是从 reward model 合成的：reward model自己模拟用户行为、自己生成 preference。

这件事的代价非常大。它意味着 GR 的 RL对齐本质上变成了”model-based RL on a learnedsimulator”——simulator（rewardmodel）本身的偏差就是新的风险来源。如果 reward model学得不准，整套对齐就会沿着错误的方向跑。这一点在 OneRec论文里没有特别强调，但是工业落地里必踩的坑。

需要进一步指出的是，reward model自身也是从历史用户行为日志训出来的 —— 它的训练标签通常是watch-time、互动、转化等多个业务指标的加权组合。这意味着 reward model学到的是” 历史日志里已经出现的偏好分布”，对没出现过的 item组合没有判断力。所以 GR + RL 对齐本质上承担两层偏差：(1) reward model作为 simulator 的偏差，(2) reward model 训练标签本身的偏差（多目标加权 +历史日志覆盖度）。第二层偏差跟传统推荐多目标建模是同一个问题，但 GR因为依赖 reward model 合成 preference，这个偏差会被 DPO 放大。

GR 在 cascade 各层的落地形态

这一节是和上一篇文章《个性化排序公式》的显式呼应 —— 把GR 范式逐层映射回cascade，看每一层分别被颠覆、被重新打开、还是仍然无解。

上一篇把推荐分成三层：

第一层 精排：单 item 打分 $s(u,i,x)$
第二层 混排：业务级流量分配，带约束的在线控制
第三层 重排：列表组合优化，包含 listwise /Slate

加上召回，cascade 实际是四层。GR对这四层的对应形态完全不同，对照如下：

cascade 环节	传统做法	GR 对应形态	代表工作	工业落地度
召回	双塔 + ANN	TIGER：生成式召回（transformer memory 替代 ANN）；HSTU：序列建模 +ANN（user encoder 升级，item 侧不变）	TIGER / HSTU	TIGER 学术有效，工业级召回未验证；HSTU 高（Meta 上线）
第一层精排	pointwise / 多目标加权	Autoregressive Ranking	HSTU	高（Meta 上线）
第三层重排 / Slate	listwise + Generator-Evaluator	直接生成 slate	OneRec、Seq2Slate 系	中（快手上线）
第二层混排（业务分流）	calibration + multiplier + pacing + score shading	硬约束 / 在线控制部分 GR 当前不解决	—	低

前三层在前面三大支柱里已经分别讲过 TIGER / HSTU / OneRec的细节，这里只点出它们跟 cascade 各层的对应关系；其中召回侧 GR实际有两条不同路线（TIGER 生成式召回 vs HSTU序列建模式召回），需要分开看。这一节真正想说的是最后一行 —— 第二层混排里硬约束和在线控制这部分，是next-token 范式天然不擅长、GR当前没法很好满足的盲区，放到最后单独展开。

召回

传统召回是 user / item 双塔学 embedding，离线建 ANN索引，在线做近似最近邻检索。GR在召回侧其实有两条不同路线，对应前面讲的两类工作：

HSTU 路线：序列建模式召回 —— 不生成 itemtoken，只是把双塔里 user 侧的 encoder 升级成 HSTU 序列模型，把更强的user state $A_t$ 投影成 queryembedding，再喂给 ANN 索引做检索；item 侧仍然是 hash ID + embedding +ANN（详见前面路线一 HSTU 的输出层讨论）。这条路线保留了 ANN索引可独立部署、可独立更新的工程优势，但牺牲了” 泛化到没见过item” 的能力。
TIGER路线：生成式召回 —— 给定历史行为序列，自回归生成下一个 item 的semantic ID（详见前面 Item Tokenization节）。这一步相对双塔召回最本质的差别不是” 换了一种 retrieval方法”，而是让召回侧第一次拥有了泛化到没见过的 item的能力。双塔召回里，没出现在训练集的 item 几乎没法被召回；而 GR召回里，只要新 item 的 semantic ID落在已学过的前缀空间里，就有可能被生成出来。代价是 transformer memory本身就是index，模型重训意味着索引重训，两者不再可以独立部署（详见前面” 与 ANN的关系” 段）。
需要特别区分两个层面 —— 召回任务和工业级召回 ——TIGER只在第一个层面被验证过：
- 召回任务层面（已验证）：TIGER论文确实做的是召回任务的实验 —— 给定用户历史，生成下一个 item 的 semanticID，再做 constrained decoding 映射回真实item。这本身就是召回任务的形态，论文标题 “Generative Retrieval” 也明确把TIGER 定位成生成式召回。
- 工业级召回层面（未验证）：TIGER 论文用的 benchmark是 Amazon Reviews 这类序列推荐学术数据集，对比的 SOTA 主要是 SASRec /BERT4Rec等序列推荐模型，不是双塔召回模型；也没有在百万 / 亿级item 池 + ANN 索引的工业召回场景下做实验。所以” vs 双塔 +ANN” 更多是范式层面的对比（用 transformer memory 替代 ANN索引），不是论文实验直接对比出来的结论。
这两层区分是 TIGER路线” 开放新可能性” 但工业落地证据相对薄弱的根源 —— 它在学术 benchmark上证明生成式召回任务本身可行，但工业级召回能不能跑过成熟的” 双塔 +ANN” 链路，目前还没有公开证据。

这两条路线的工业落地度差别很大：TIGER 路线只在学术 benchmark（如Amazon Reviews，对比对象是 SASRec / BERT4Rec等序列推荐模型）上验证过生成式召回任务本身可行，没有在百万/亿级 item 池+ ANN 索引的工业召回场景下做过实验、也没有公开上线证据；HSTU 路线随 HSTU在 Meta多产品上线而天然带量。换句话说，召回侧真正已经在工业跑通的 GR形态，是 HSTU 那条” 序列建模 + ANN” 的路，而不是 TIGER那条” 完全生成式” 的路 —— 后者更像” 开放新可能性的方向”，前者是” 已经被验证的落地形态”。

第一层精排

HSTU 是对 cascade 第一层最根本的挑战 —— 不再 pointwise 打分，而是next-action 序列预测（把推荐从” 逐 $(u,i)$打分” 重述成” 给定历史行为序列，预测下一步可能发生什么行为”）。不再把” 多目标加权” 当作核心，而是用scaling law +大模型容量自动学多目标之间的隐式权衡（详见前面路线一）。

跟前面三大支柱唯一需要在这里强调的差别是：HSTU挑战的是上一篇里” 第一层打分公式 $f_\theta(u,i,x)$“这个数学形式本身，不是item 表征。HSTU 没有用 semantic ID，官方实现里大部分还是 hash体系 —— 这意味着即使一个团队不打算切 semantic ID，也可以独立尝试HSTU。这一点是 GR 在精排和召回两层可落地性差异的根源。

第三层重排 / Slate

OneRec（arXiv:2502.18965）用一个encoder-decoder 一口气生成整张 list，是上一篇里第三层最自然的演进。

上一篇把第三层方法分成三类：约束重排、列表重排、Slate优化。其中” 列表重排” 最常见的工业实现是Generator-Evaluator：generator产出多条候选排列，evaluator 给每条排列打整体效用分。OneRec把这两件事统一在一个 transformer 里：

decoder 既是 generator（自回归生成排列），又通过 next-token loss隐式承担 evaluator 的角色
训练时用 RQ - VAE semantic ID 表征 item，让” 相邻 item” 在 token空间也相邻
用 DPO 做偏好对齐（详见前面” 训练目标：从 next-token到偏好对齐” 节）

也就是说，OneRec 把 listwise 和 Slate两件事统一在一个生成框架里，是上一篇第三层的” 下一代形态”。

第二层混排：硬约束与在线控制是GR 当前盲区

这是这一节最重要的一段，也是最容易被忽略的一段。

上一篇里第二层混排做的事情是”多业务之间、带约束的流量分配”：calibration、multiplier、pacing、scoreshading、最小流量保护、广告 load 上限…… 这些问题需要区分两类来看：

软偏好类（多目标之间的隐式权衡、用户偏好对齐）—— 这一部分可以放进GR 框架，用 DPO / reward 对齐来学（详见前面” 训练目标：从 next-token到偏好对齐” 节）
硬约束 + 在线控制类（pacing、load 上限、scoreshading、calibration）—— 这一部分是 next-token 范式天然不擅长、GR当前没法很好满足的盲区

后一类问题的共同特征是：它们不是” 预测下一个token” 的问题，而是”在受约束的资源条件下做在线控制” 的问题。

next-token 范式天然不适合表达这类问题：

pacing 控制器需要长时间窗口的反馈累积，next-token loss 是逐步的
load 约束是硬约束、不是软偏好，DPO 风格的 reward 对齐不适合表达
score shading本质是一个对偶变量（影子价格）的在线估计，更像控制论问题而不是生成问题
各业务的 calibration 量纲对齐也不是” 生成” 能解决的

所以即使一个团队全面切了GR，业务级混排层（第二层）里硬约束和在线控制这部分仍然要保留传统方法。这是GR 工业落地非常重要、但很少被论文讨论的一个事实。

总的来说，GR对第一层是颠覆性的（HSTU），对召回是开放新可能性的 ——TIGER那条完全生成式召回是” 新可能性的方向”，HSTU 那条” 序列建模 +ANN” 是” 已被验证的落地形态”，对第三层是统一性的（OneRec）；第二层混排里软偏好可放进GR 框架，但硬约束与在线控制部分（pacing / load / score shading /calibration）next-token范式天然不擅长，仍然要保留传统方法。

实际落地可行性判断

这一节把前面散落各处的判断收拢成一张可操作的清单。判断 GR在具体业务上是否可行，关键不是” 它整体是不是噱头”，而是把它拆成若干独立技术点 —— 每个点的工业证据强度不同。下面先逐项过证据，再落到” 什么业务现在该试” 和” 怎么试”。

技术点	工业证据	主要依据
Semantic ID / RQ-VAE	已验证	TIGER 实验充分；OneRec、HLLM 都依赖它；是生成 item token路线的前提
HSTU + 推荐 scaling law	已验证（最强）	Meta 1.5T 参数上线
端到端 GR 替代 cascade	短视频 / 本地生活已有公开验证，独立验证仍有限	OneRec / OneLoc / OneRec V2等快手技术谱系案例较完整，但跨公司验证不足
LLM-as-Recommender（P5 / BIGRec / LlamaRec）	学术有效，工业未验证	benchmark 漂亮；延迟和行为信号注入两个根本问题没解决
GR + DPO 偏好对齐	短视频已验证，稀疏 reward 未解	OneRec 在 watch-time 上有效；稀疏 reward 场景没解
GR 解决冷启动	证据较强	semantic ID + content encoder 天然带语义结构；HLLM 长尾实验证据
GR 替代业务级混排	GR alone 不能替代	pacing / load / calibration 仍需要外部控制器和传统在线控制机制
GR 推理延迟	仍是瓶颈	OneRec V2 砍掉 94% 算力是进展，但相比 cascade 仍偏高

如果一个业务同时满足下面多条，那么尝试 GR 是值得的：

行为数据量足够大：scaling law才能起作用。一个粗略的经验门槛是亿级 DAU、十亿级日交互
主反馈稠密及时：短视频 watch-time、信息流停留这种dense reward 是 GR + RL 对齐能起作用的前提
业务对 item 内容理解 / 冷启诉求强：内容平台、UGC平台、跨域推荐
召回环节明显是瓶颈：双塔召回上限明显，长尾覆盖差，那么generative retrieval 是收益最直接的入口
列表组合质量诉求高且目标相对单一：feed 场景的 slategeneration 受益最大

反过来，如果业务有下面任何一条特征，那么短期内不建议把 GR当作主要方向：

强约束、强多目标：广告、电商场景同时要管load、pacing、calibration、营收。GR可以学习部分软偏好，但很难单独承担这些硬约束和在线控制
推理延迟极敏感：搜索、广告 RTB这种几十毫秒预算
业务数据规模不够大：scaling law用不出来，反而被通用架构拖累
主反馈稀疏延迟：长留存、复购、转化为主目标的场景

如果决定推进 GR，一个相对稳健的路径是分阶段：

先把 semantic ID 落地，逐步替代 hashID。这一步即使不上完整 GR，也能在冷启动和长尾上拿到收益
召回侧做 generative retrievalpilot，和现有双塔召回并行小流量验证
精排侧尝试 HSTU 风格的 scaling实验，先看在自己业务上 scaling law是否真的成立 —— 这是决定后续投入的关键决策点
当 1-3 都验证后，再考虑 slate generation + DPO对齐
业务级混排层（带约束分流）保留传统方法，不要试图用 GR 替代全部

这个路径背后的逻辑是：每一步都保留了回退余地，每一步的 ROI都可以独立评估。和直接” 端到端上 GR” 相比，工业风险低得多。

总结

回到标题的问题：GR 替代的不是 cascade 这个系统形态本身，而是cascade 背后的一部分建模假设。

它首先替代的是 “item 只是无结构 ID” 的假设。semantic ID / RQ - VAE 把item 从一个 hash key 变成有层级结构的token，这对冷启动、长尾和生成式召回都很关键。但这主要服务于 TIGER /OneRec 这类生成 item token 的路线，并不是所有 GR 形态的前提。

它也替代了 “每个 item 可以独立打分” 的部分假设。HSTU 把推荐从 pointwise打分推进到行为序列建模，并且在大规模 compute 下展示了推荐模型的 scalinglaw；OneRec 则更进一步，把召回、排序、slate生成压进一个端到端生成框架里。两者都叫 GR，但工程含义完全不同：HSTU更像是级联系统里的强 backbone，OneRec 才是在挑战 cascade的整体链路。

但 GR 没有替代业务级混排和在线控制。pacing、load、calibration、scoreshading 这些问题本质上是带约束的资源分配，不是 next-token prediction。GR可以学习软偏好和部分多目标权衡，但硬约束仍然需要外部控制器和传统机制兜底。

所以更准确的判断是：GR 不是 cascade的终结，而是把推荐系统里的若干关键环节重新打开了。semantic ID和 HSTU 的工业证据已经比较强；端到端 GR 以 OneRec技术谱系为代表，短视频和本地生活场景已有公开验证，但跨公司独立验证仍然有限；LLM-as-Recommender在主流推荐链路里仍更像局部增强，价值主要在长尾、冷启、内容理解和对话式场景。

如果一个业务行为数据极大、反馈稠密及时、约束相对单一，GR值得系统性投入；如果业务延迟极敏感、硬约束很多、reward 稀疏且延迟，GR更适合作为局部模块试验，而不是直接替代整套 cascade。

参考文献

Understanding ScalingLaws for Recommendation Models (Ardalani et al.,arXiv:2208.08489)
Recommender Systems withGenerative Retrieval (TIGER, NeurIPS 2023)
Actions Speak Louder thanWords: Trillion-Parameter Sequential Transducers for GenerativeRecommendations (HSTU, ICML 2024)
OneRec: Unifying Retrieveand Rank with Generative Recommender and Iterative PreferenceAlignment
OneRec TechnicalReport
OneRec-V2 TechnicalReport
OneLoc: Geo-AwareGenerative Recommender Systems for Local Life Services
HLLM: EnhancingSequential Recommendations via Hierarchical Large Language Models forItem and User Modeling
Large Language Models AreUniversal Recommendation Learners (URM)
P5: Recommendation asLanguage Processing
LlamaRec: Two-StageRecommendation using Large Language Models for Ranking
BIGRec: A Bi-StepGrounding Paradigm for LLMs in Recommendation
MTGR: Industrial-ScaleGenerative Recommendation Framework in Meituan (KDD 2025)
个性化排序公式：从个性化精排到个性化混排再到全局重排（本博客上一篇）

个性化排序公式：从个性化精排到个性化混排再到全局重排

2026-06-07T06:20:00.000Z

“个性化排序公式” 是推荐系统里老生常谈的话题，但很多时候，这个词其实指代不清，因为我们经常把三层不同的问题混在一起说。

更准确地讲，推荐系统里的个性化排序，通常至少包含三层：

第一层：个性化精排，回答的是 “这个用户看到这个item，大概价值是多少”
第二层：个性化混排，回答的是 “在多个业务同时竞争流量时，这次曝光机会应该先给谁”
第三层：全局重排，回答的是 “用户最终看到的是一整张列表，这张列表该怎么拼才最好”

很多推荐系统做到今天，第一层其实已经足够强了。

User embedding、item embedding、多任务学习、crossfeature，这些东西的目标都很明确：让模型尽可能准确地回答一个问题:这个用户看到这个内容，大概价值是多少。从这个意义上说，很多系统的排序公式早就已经是个性化的了，只不过这种个性化不是显式写成 “每个用户一组权重”，而是被模型隐式学进了参数里。

但真实系统往往会出现一个看起来有点矛盾的现象：第一层已经很强了，线上仍然还在做第二层混排、控量、保量，以及第三层重排，甚至还要单独做score calibration、pacing、shading、listwise rerank。

如果只是从直觉上理解，很容易把这件事解释成一句话：第一层还不够准，所以第二层和第三层是在打补丁。这个解释不能说错，但它只解释了一半。

因为更本质的问题在于：第一层、第二层、第三层，优化的根本不是同一个对象。

第一层优化的是单个 item 的价值预估
第二层优化的是多业务之间、带约束的流量分配
第三层优化的是整张列表的组合质量

也正因为如此，“个性化排序公式” 真正值得讨论的，并不只是 “不同用户的权重为什么不同”，而是：当第一层已经能够较好学习用户对单个item的偏好之后，平台为什么还必须引入第二层个性化混排和第三层全局重排？它们分别在弥补什么，又分别在优化什么？

本文想讨论的，正是这个三层问题。

为了避免后面分层细节淹没主线，先给一张全景图把三层的优化对象、关键方法和边界放在一起：

第一层解决了什么

从数学形式上看，第一层精排通常学到的是一个函数：

\[s(u,i,x) = f_\theta(u,i,x)\]

其中，$s(u,i,x)$是第一层精排给出的分数 / 预估价值，$f_\theta$ 表示参数为 $\theta$ 的打分函数；$u$ 是用户，$i$ 是 item，$x$ 是上下文，$\theta$是模型参数。这个分数本质上在回答：

在当前上下文下，把这个 item 展示给这个用户，预期能产生多大价值？

这个价值可以是单目标，比如 CTR；也可以是多个目标的组合，比如：

\[s(u,i,x) = w_1 \cdot CTR + w_2 \cdot CVR + w_3 \cdot WatchTime + w_4\cdot GMV\]

这里，$w_1, w_2, w_3, w_4$表示不同目标的组合权重；CTR、CVR、WatchTime、GMV分别表示点击率、转化率、观看时长和成交金额等目标信号。

如果模型足够强，它当然可以学到很深的个性化差异：

有的用户更偏停留时长
有的用户更容易被电商内容转化
有的用户对广告非常敏感
有的新用户更需要稳定体验，有的老用户更能接受更强的个性化分发

所以，从 “用户和内容是否匹配” 这件事本身来说，第一层已经能做得很深入。它真正擅长的是一句话：

这个用户看这个 item，大概值多少钱。

问题在于，推荐系统要解决的，从来不只是这一件事。

单 item 打分为何不够

如果只靠第一层精排就想做完全部决策，至少要同时满足下面四个条件（假设）。

这四个条件其实分两组：

（1）单项可加 和 分数同量纲决定的是pointwise「加和 - 排序」这种范式在数学上能否成立，是第三层（列表组合优化）出现的根本原因
（2）没有额外全局约束 和 环境是静态的决定的是问题本身是否还带有资源约束与时间维度，是第二层（流量分配与在线控制）出现的根本原因

单项可加

也就是说，最终列表的整体效用必须满足：

\[U(\pi) = \sum_{k=1}^{K} v(u, i_{\pi_k}, k)\]

这里，$U(\pi)$ 表示排列 $\pi$ 的总 utility /总价值；为了简化记号，这里省略了它对用户和上下文的依赖。$K$ 表示列表长度，$i_{\pi_k}$ 表示排在第 $k$ 位的 item，$v(u, i_{\pi_k}, k)$ 表示该 item 在位置$k$ 上给用户 $u$带来的单项价值。这个公式其实已经隐含了一个很强的假设：每个 item的价值只取决于用户、item 本身和位置，而不依赖于列表里的其他item。

但真实系统里，这个假设经常不成立。更常见的情况是：

\[U(\pi) = \sum_{k=1}^{K} v(u, i_{\pi_k}, k) + \sum_{k

其中，第二项里的 $g(i_{\pi_k}, i_{\pi_l},u)$ 表示两个 item 在同一张列表里共同出现时，对用户 $u$产生的额外相互作用，比如互补、替代、疲劳或多样性收益。比如：

两条高度相似的视频连着出现，第二条往往就没那么想看了
同一类内容连续刷太多，用户会更容易疲劳
图文、短视频、直播如果穿插着来，用户通常会比一直看同一种内容更不容易腻
不同位置适合的内容也不一样，比如前面的位置更适合抓眼球的内容，后面的位置更适合承接兴趣的内容
用户看一整页时，感受到的不只是单条内容好不好，还包括这一页够不够丰富、够不够新、是不是更贴近自己当下的场景

一旦这个项存在，pointwise 的单 item打分就不足以推出最终列表最优。

分数同量纲

这个条件在现实里也几乎不会成立。

因为不同业务、不同模型、不同目标的分数，往往天然不是一个量纲：

图文精排的 0.4
直播精排的 0.2
广告的 eCPM
电商的 GMV 预估

这些分数背后的训练目标、样本分布、噪声水平和业务含义都不一样。即使它们都 “看起来像一个分数”，也不代表它们能直接比较。

所以，第一层很难做到完全估准，多目标之间也很难做到真正同量纲，这确实是后面需要第二层和第三层的重要原因之一。

但这还不是全部。

没有额外全局约束

如果系统只需要最大化某个统一效用，那第一层确实更容易一把梭。

但真实推荐系统通常还会带着很多作用在 “整体结果” 上的约束：

营销业务（如广告、电商、直播）的 load 约束（本质是 LT，但可能会以load 作为外显）
营销感打散（即不能同时出多个营销型 item）
多样性
作者 / 商家公平
平台生态平衡
….

这类约束不是作用在某个单 item上，而是作用在整张列表、整段时间窗口、甚至整个流量池上。因此，单个 item分数再准，也不等于系统能自动满足这些约束。

环境是静态的

如果流量环境是静态的，排序问题会简单很多。

但真实系统面对的是持续变化的动态环境：

某个业务这小时是不是已经出太多
用户是不是已经看腻
当前是不是该保留探索流量
某类供给是不是突然变少了

到了这里，问题已经不只是 “排序”，而是带有明显控制色彩的动态决策问题。

所以，现实中的推荐系统并不是在解一道 “给每个 item打分然后排序” 的静态题，而是在解一道 “在约束下分流量、拼列表、保稳定” 的动态系统题。

这就是为什么第一层已经很强了，第二层和第三层仍然不可省略。

第二层的职责：在多业务之间分流量

很多推荐系统里，参与竞争的并不是单一内容源，而是多个业务共同争夺曝光机会，比如：

图文
短视频
直播
电商卡片
广告
本地生活内容

每个业务内部通常都已经有自己的召回、粗排、精排链路，也都能比较好地回答 “自己家候选谁更好”。但平台真正要回答的问题不是 “这个业务内部谁更值得出 “，而是 “这一次曝光机会，到底应该给哪个业务？“

这已经不是单 item预估问题，而是一个典型的跨业务资源分配问题。

而且这个问题通常还天然带着一堆平台约束：

某业务有渗透目标
某业务的 load 不能掉太多
广告不能超量
平台不希望某一类内容长期把其他体裁挤穿
某些业务当前体验已经紧张
某些业务在当前时段服务器或供给容量有限
某些业务的精排分不适合直接和别的业务硬比

这时，平台真正面对的更像是下面这种问题。其中，$\text{MixUtility}$表示混排层希望最大化的整体收益；$\text{Load},\text{Budget}, \text{Quota}, \text{Risk}, \text{Fairness}$则分别表示流量占比、预算、配额、风险、公平性等平台约束：

\[\begin{aligned}\max \quad & \text{MixUtility} \\\text{s.t.} \quad &\text{Load},\text{Budget},\text{Quota},\text{Risk},\text{Fairness}\end{aligned}\]

到了这里，第一层即使把每个 item的价值预估得再准，也不能自动回答 “流量应该怎么分”。

平台仍然需要一个额外的决策层，去处理：

不同业务之间如何校准
当前预算和目标下，哪个业务更值得拿这次流量
某个业务是该提价、降价、保量还是控量
如何在局部收益和整体稳定性之间做平衡

这就是第二层混排存在的原因。

这里有一个例子：

假设某个用户明显喜欢直播，不太喜欢图文。那么最直接的想法是：在混排里把直播整体权重抬高。

这件事在很多时候是有效的，因为它解决的是：这次流量更应该从直播队列拿，还是从图文队列拿？

但这里有一个边界也必须明确：第二层只能决定 “流量给谁”，不能决定 “这个业务内部哪条最该出”。

如果直播业务内部 top1恰好是一条强卖货直播，而这个用户真正喜欢的是 “讲知识点的轻直播”，那么混排层即使不断提高直播权重，也只是更频繁地把 “不适合的直播” 推给用户。因此，第二层虽然必要，但它有天然上限：它更像一个业务级的调度器，而不是item 级的最优选择器。

如果把每个业务都看成一个已经排好序的队列，那么第二层做的事情可以非常直观地理解成：

不动各业务内部顺序
每次决定 “下一张卡从哪个业务拿”

也就是说，第二层优化的并不是单个 item，而是业务级 / source级的流量调度策略。

这里有一个很容易产生的误解是：第二层是不是本质上就是各参与方不断调整自己的权重项，尽量把彼此的价值量纲对齐？

这个理解只说对了一半。

因为第二层确实包含 “让不同业务的分数尽量变得可比” 这件事，但这只是第二层的起点，而不是它的全部。更完整地说，第二层实际上在做两步：

1）先把不同参与方的局部价值映射到一个大致可竞争的空间里
2）再在这个空间上，结合平台侧的约束、预算状态和流量目标，做带约束的动态流量分配

所以，量纲对齐更像是第二层的 “入场券”，而受约束的资源分配才是第二层真正的主体问题。

从这个角度看，下面这些方法本质上都属于第二层：

score calibration
personalized multiplier
quota / pacing
score shading / bid shading 风格的动态调分
各种带约束的保序混排

因此，第二层并不只是对 “不够准的精排分” 做修补，它更像是给平台增加了一层新的能力：

在不改动各业务内部排序的前提下，做一层受约束的、动态的、个性化的流量控制。

第二层的方法：不改变精排序的个性化混排

上面讲的是为什么第二层一定会存在。接下来再看，这一层具体有哪些主流方法。

分数校准

这是最容易被忽略、但在工程上最关键的一步。

因为不同业务的精排分，往往天然不是一个量纲：

图文精排的 0.4
直播精排的 0.2
广告 eCPM 的 15
电商 GMV 预估的某个归一化值

这些分数如果直接拿来PK，通常没有意义。因为它们对应的模型目标、样本分布、训练方式和业务含义都不一样。

所以，在真正进入个性化混排之前，平台往往要先做一层calibration，包括：

分桶校准
分位数归一化
Platt Scaling / Isotonic Regression
按 user segment / 场景做条件校准

或者就是最简单的根据不同业务过去一段时间的 avg的量纲的差距，直接拍一个一段时间内固定的系数用来做量纲的对齐。这一步的本质是：先解决 “能不能比” 的问题，再去解决 “怎么分” 的问题。

如果没有 calibration，后面的 personalized multiplier、pacing、shading都会失真。

动态调权

当不同业务的分数已经大致可比较后，最直观的一种做法就是对业务级得分做动态加权：

\[\text{MixScore}_{u,b} = \alpha_{u,b}(x) \cdot \text{CalibScore}_b\]

其中：

$\text{MixScore}_{u,b}$ 表示用户$u$ 在当前请求下，对业务 $b$ 的混排分
$\text{CalibScore}_b$ 表示业务$b$ 在经过量纲对齐后的可比基础分
$b$ 表示业务 / source
$\alpha_{u,b}(x)$ 表示用户 $u$ 在上下文 $x$ 下对业务 $b$ 的偏好权重

例如：

某些用户更偏直播，就提高直播 source 的 multiplier
某些用户更偏图文，就提高图文的权重
某些场景更适合短视频，某些场景更适合电商卡片

这种方法的优点是简单、直观、可解释，而且非常适合已有多业务体系的线上系统。它本质上还是 “保序混排”—— 只调业务间的相对竞争力，不改业务内部顺序。

但它的上限也很明确：它只能回答 “这次流量给谁”，不能回答 “这个业务内部哪条最该出”。

ScoreShading / Pacing：把混排看成受约束的动态出价问题

再往前一步，平台会发现：光有用户偏好权重还不够，因为很多问题本质上不是 “喜不喜欢”，而是 “在当前约束下，这次流量值不值得拿”。

这时，一个很自然的视角是把混排中的业务分看成 “隐式出价”。

如果广告中的 bid shading 解决的是：

在一价拍卖里，如何在保持获量能力的前提下，降低成本、提升 ROI？

那么混排中的 score shading 解决的就是：

在不改业务内部排序的前提下，如何动态调节业务的 PK分，在渗透、成本、稳定性之间找到更优平衡？

例如，对于某个业务，可以把问题写成：

\[\begin{aligned}\max_{s_i} \quad & \sum_i V_i F(s_i) \\\text{s.t.} \quad & \frac{1}{n}\sum_i s_i F(s_i)\le C\end{aligned}\]

其中：

$V_i$：第 $i$ 次机会下，该业务胜出后的价值
$s_i$：当前业务在这次机会中的混排score / PK 分
$F(s_i)$：在分数 $s_i$ 下的竞胜率
$n$：统计窗口内的机会数 /样本数
$C$：成本或量纲约束

通过拉格朗日对偶，可以把它转成单次请求下的决策问题：

\[s_i^\star = \arg\max_{s_i} F(s_i) \left( V_i - \lambda s_i \right)\]

这里的 $\lambda$严格说是成本约束的拉格朗日乘子（也就是影子价格），工程上通常用 pacing控制器（PID / EMA 等）在线估计它，使得长期平均成本贴近约束 $C$；$s_i^\star$ 表示在第 $i$ 次机会下的最优混排 score / 最优 PK分。

这个公式非常有代表性，因为它体现了一件事：第二层不是在 “修一个不准的分数”，而是在做一个受约束的在线控制问题。

这个方法最关键的一步其实不是公式本身，而是如何建模 $F(s)$，也就是竞胜率模型。这里的$F(s)$ 可以理解为 “给定一个待评估的score $s$，当前业务赢下竞争的概率”。

直观地说，可以有两种思路：

点估计：直接建模 $P(\text{win}=1|s,\text{context})$，其中$P(\text{win}=1|s,\text{context})$表示在给定分数 $s$ 和当前上下文 $\text{context}$时，本业务赢下这次竞争的概率
分布估计：不直接建模胜率，而是建模 “对手最高分的分布”，再由分布推导胜率

前者更直观，后者更完整。

一个非常有代表性的工作是 Deep Landscape Forecasting forReal-time Bidding Advertising。它不直接学习某个 bid下的赢面，而是学习竞争景观（landscape）的分布参数，从而可以解析地得到任意出价下的win rate。这种思路迁移到混排里同样成立：如果你真正想做 scoreshading，很多时候需要的不是 “某个分值下会不会赢” 的点判断，而是 “当前竞争环境长什么样” 的整体刻画。

虽然 Score shading看起来能更好地提升效率，但这个方法如果没有约束，很容易从局部优化变成全局风险。

具体来说，如果平台放任各业务都自己做shading，会很容易出现两个问题：

（1）分值通缩

所有业务都在想办法 “用更低的分赢到量”，久而久之，整个系统的绝对 score会左移，最后可能击穿很多依赖绝对值门槛的策略逻辑。

（2）控制震荡

当多个业务都用自己的 PID / pacing控制器去调分时，它们会在同一流量池里相互影响，形成耦合震荡。最常见的现象就是：上一分钟直播拿太多，下一分钟短视频暴力反补，整个平台呈现高频抖动。

所以，score shading真正要落地，往往不仅是一个模型问题，更是一个平台机制问题。通常至少要引入下面两种治理思路中的一种：

全局锚点（anchor）：给系统固定一个相对稳定的 “价值基准”
统一记账机制：让各业务的竞争不只是看 “谁报得高”，而是看 “谁真正带来了更高的全局价值”

关于 Score Shading 这个方法的更多细节，可以参考这篇文章：《从 Bid Shading 到 ScoreShading：混排优化的建模、控制与博弈》

第三层的职责：把整张列表组合得更好

如果说第二层主要在解决 “流量怎么分”，那第三层解决的则是另一个更本质的问题：用户最终消费的不是单个item，而是一整张列表。

在第二层里，系统主要回答的是：这次流量先给哪个业务、哪个source。它面对的核心对象，仍然是业务级竞争和流量分配；即使里面有quota、pacing、load之类的约束，很多时候解决的也是业务级、时间窗口级、资源份额级的问题。

但到了第三层，问题变了。系统真正要回答的是：最终给用户看的这张列表，到底该怎么拼。

这也是第三层和第二层最根本的区别：第二层更像在决定 “量先给谁”，第三层则是在决定 “这张列表本身长什么样”。前者主要管source 之间的竞争关系，后者直接面对 top-k的排列、位置、上下文和组合质量。

这句话看起来平常，但它意味着一件非常重要的事：单 item最优，不等于列表最优。

第一层默认的逻辑通常是：谁分高谁排前面。这个逻辑隐含了一个很强的假设：列表总价值可以拆成每个item 价值的简单加和。

但现实里，这个假设经常被打破。

最直观的例子就是内容疲劳。假设某个用户的 top-4 候选分数分别是：

视频 A：0.90
视频 B：0.88
视频 C：0.87
图文 D：0.80

如果直接按分数排，前三条可能全是高度相似的视频。单看每条内容都没问题，但组合起来，用户体验未必最好。也许把第三条换成图文D，整页满意度反而更高。

这说明：即使第一层已经把每个 item 的单点评分做得很准，按pointwise 分数贪心排序，也未必等于最终 top-k列表的全局最优。

这就是第三层存在的根本原因。

它解决的已经不是 “这个 item值多少钱”，而是：这张列表怎么拼，才能让整体效果最好？

第三层的方法：允许直接改精排序的全局重排

到了第三层，优化对象不再只是 “哪个业务赢这次曝光”，而是整个排列：

\[\pi^\star=\arg\max_{\pi} U(u,\pi)\]

其中，$U(u,\pi)$ 表示用户 $u$ 在看到排列 $\pi$ 时，这整张列表带来的总 utility /总价值；$\pi$ 表示最终列表，$\pi^\star$则表示使该目标最大的最优列表。

系统真正关心的是：

top-k 的整体体验
item-item 的替代与互补
多样性
位置偏置
公平性
长期价值

因此，这一层的方法会比第二层复杂得多。在展开具体方法之前，先建立一张总览。第三层里至少有两步：

先把单个 item 的 utility 定义得更合理。item级个性化权重属于这一步，它解决的是 “这条内容本身值多少钱”
再把最终列表优化得更合理。约束重排、列表重排、Slate优化属于这一步，它们解决的是 “这些 item放在一起之后，整张列表该怎么组”

如果打个比方，item级个性化权重更像是在定义 “每块砖值多少钱”；而后面三类方法，则是在决定 “这些砖该怎么砌成一堵墙”。

沿着这个角度继续往下拆，第二步里又可以分成三类，从「硬规则」到「软质量」再到「时序长期价值」逐步抬高：

约束重排：先回答 “哪些列表不能出”
列表重排：再回答 “在能出的列表里，哪一张更好”
Slate优化：进一步回答 “这张列表不仅影响当前，还会沿着用户消费过程持续影响后续行为”

下面分别展开。

item 级别的个性化权重

需要先做一个边界说明：item级个性化权重严格说位于第一层和第三层的边界上，本文把它放在第三层讨论，是因为只有当它作为「精排之后额外的一层utility调整」存在时，它才属于第三层；如果直接做在精排模型内部，它本质上仍是第一层。下面的讨论默认前者。

这一步最常见、也是工业上最容易落地的一类方法，是直接对 item 级utility 建模：

\[U(u,i,x) = \sum_k w_k(u, x)\,\phi_k(i, x)\]

其中：

$U(u,i,x)$ 表示用户 $u$ 在上下文 $x$ 下看到 item $i$ 时，这个 item 带来的 utility /价值
$\phi_k(i,x)$ 表示 item $i$ 在上下文 $x$ 下第 $k$ 个目标上的信号或预估值，比如CTR、CVR、GMV、时长、留存、商业价值等
$w_k(u,x)$是与用户和上下文相关的动态权重
$k$ 表示不同目标的索引

和第二层的 business multiplier 相比，两者形式上都是「权重 ×分数」，但作用对象完全不同：第二层的乘子作用在 source /业务级上，调的是「这次流量给哪个业务」，业务内部顺序不变；这里的权重作用在item 级 上，调的是「这条内容本身的 utility是多少」，因此会直接改变 item 之间的相对顺序。

这类方法的本质，其实更准确地说是：当多目标之间的 trade-off会随用户和场景变化时，系统可以选择把这种差异隐式学进统一打分函数，也可以显式写成item级动态权重。因为只要模型表达能力足够强，特征也覆盖了用户状态和上下文，同一套共享参数同样可以学出 “白天通勤” 和 “晚上休息” 的不同偏好。

如果直接用统一的黑盒模型去学，那么也可以写成 $U(u,i,x)=f_\theta(u,i,x)$；此时个性化的多目标trade-off 被隐含在这个 black-box utility function 里。如果写成 $U(u,i,x)=\sum_k w_k(u,x)\phi_k(i,x)$这种形式，那么系统就是把 “当前更看重CTR、GMV、时长还是留存” 这件事，直接拿到台面上来建模。

通俗一点说，就是：不是 “同一套参数行不行” 的问题，而是 “不同的人、不同的时候，心里那把尺子要不要始终固定不变” 的问题。比如：

对高消费用户来说，一条带货内容里的 GMV、CVR可能更重要；但对轻娱乐用户来说，更重要的可能是时长、完播和消费负担更低的娱乐体验
对新用户来说，系统可能更看重留存、稳定体验和低打扰；对老用户来说，则可能更强调点击、转化或者更强的个性化探索
即使是同一个用户，白天通勤、晚上休息、周末闲逛，也可能对应三套不同的价值权重：有时更看效率，有时更看放松，有时更看消费决策

因此，显式动态权重的价值，很多时候不在于 “黑盒模型做不到”，而在于它提供了更强的可控性、可解释性和工程上的可分解性。

这个权重学习的方法有很多，工业界常见有三类方案：supervised端到端融合、contextualbandit、actor-critic。它们看似都在学同一个权重函数$w_k(u,x)$，但回答的是三个不同的问题：

方法	它在回答什么问题	反馈结构	是否建模” 动作影响未来”	优化目标
Supervised 端到端融合	从历史日志看，什么 $w_k$让最终列表指标最高？	(context, label) 静态对	否	离线 loss（最终指标的代理）
Contextual Bandit	这一次曝光，选什么 $w_k$使单步 reward 最高？怎么探索新组合？	(context, action, reward) 单步	否	单步即时 reward
Actor-Critic	这次动作会改变用户后续状态，怎么选 $w_k$ 使长期累积 reward最高？	$(s, a, r, s')$ 序列	是	$\sum_t \gamma^t r_t$

通俗一点：

Supervised端到端像考完试看答案：拿历史日志当训练集，让模型直接逼近” 最终指标”。简单稳定，但只能在已有数据分布里内插 —— 日志里没出现过的$w_k$ 组合就是黑洞
Contextual Bandit像每次掷骰子前先估一下哪个骰子更好、掷完立刻调整。和 supervised的核心差别是它会主动探索；和 RL的核心差别是它假设每次决策独立，不考虑” 当前动作怎么影响下一刷的用户状态”
Actor-Critic 把推荐看成MDP：当前选择会改变下一步用户行为，Critic估” 从当前状态出发未来还能拿多少 reward”，反传给 Actor学权重。本质增量是承认动作会改变未来，代价是要稳定的dense reward 信号、要解决高方差和分布漂移

在实际中，三者并不是替代关系，实际链路里经常叠加使用：主线用supervised 学一个保底的 $w_k$；contextual bandit在小流量做在线探索；actor-critic 用来优化更长期、更累积的目标（如LTV、session 留存），而不是替换 supervised 学的即时目标。

下面专门展开 actor-critic在工业里的实际落地情况 —— 它是三类方法里争议最大、也最容易讲偏的一种。

一种比较常见的做法是用 Actor-Critic / DDPG 直接学$w_k(u, x)$：Actor 在给定 $(u, x)$ 下输出多目标权重，Critic评估当前曝光 / 列表的整体 utility，reward 设为观看时长、完播率、互动信号 等。

在短视频、直播这类反馈密集、即时性强的业务里，这套链路是真正能 work的：每次曝光都能拿到 dense reward，回流也快，Critic 学得动，Actor也就有了稳定的梯度信号。快手、字节、阿里等内容 / 电商平台在多目标融合权重上都有这类实践。但 RL在这一步要落地，至少要满足两个前提：

Reward 足够稠密、及时：watchtime、完播、停留这类信号每次曝光都有，归因明确；如果换成转化、留存、复购这类稀疏延迟信号，off-policy评估、归因稳定性都会迅速变差
Critic 真的能学到列表 / 曝光的整体 utility：否则Actor学到的权重很容易只优化某个单点目标（比如时长被放大、互动被牺牲），反而破坏多目标平衡

如果业务的主反馈本身就是稀疏或延迟的（电商点击 - 转化、长留存等），那么supervised 端到端融合 或 规则 +分群权重 仍然是性价比更高的选择；contextual bandit介于两者之间，适合做在线探索补充。

接下来三节进入第二步 ——「这些 item 放在一起怎么组」。

约束重排

在很多业务里，平台并不是 “希望” 满足某些条件，而是 “必须” 满足某些条件，比如：

广告 load 上限
某类作者最低曝光
某些风险内容上限
某业务配额
类目覆盖要求

这一层之所以必要，恰恰是因为第二层虽然已经在业务级上处理了一部分约束，但还没有真正解决 “这一屏最终能不能这么出” 的问题。

举个例子，如果平台要求 top-10 里广告不能超过 2条、同作者内容不能连出、某类内容至少保留 1 个坑位，那么：

第一层可能会把 3 条广告都打得很高
第二层也许已经把广告业务的整体流量控制在合理区间
但落到某一次具体请求、某一个具体 top-k 上，系统仍然可能违反规则

所以，这一层之所以能改掉前面的排序，并不是因为它拿到了某个神秘的新特征，而是因为它把前面只在业务级、时间窗口级上粗粒度处理过的约束，推进到了单次请求、最终列表级去显式求解。

也就是说，约束重排真正拿到的增量信息，不是 “这条 item又多了一个特征”，而是 “这张列表当前已经放了什么、还剩几个坑位、哪些约束已经快撞线了”。这些信息只有在最终list 组装阶段才是完整的。

这时候，简单的 penalty 或 multiplier往往不够，因为它只能 “倾向性地” 推动结果，而不能稳定保证约束成立。权重调轻了，约束可能失效；权重调重了，又可能把整体relevance打掉。更麻烦的是，很多约束本身还是离散的、位置相关的、相互耦合的，天然就不是单个分数能顺滑表达的。

更自然的做法是把问题写成：

\[\begin{aligned}\max_{\pi} \quad & U(\pi) \\\text{s.t.} \quad & C_j(\pi) \le 0\end{aligned}\]

这里，$C_j(\pi)$ 表示排列 $\pi$ 在第 $j$ 个约束上的违反程度；当 $C_j(\pi) \le 0$ 时，说明该约束被满足。

这类 constrained re-ranking的核心不是 “把分再调一调”，而是明确承认：最终排序不是一个纯 relevance最优化问题，而是一个带硬约束的组合优化问题。

工业上常见的做法，可能是带规则的 greedy /swap，也可能是拉格朗日松弛、最小费用流、ILP这类更显式的约束优化。形式可以不同，但本质都一样。

因此，约束重排真正补上的，是前面没有解决的 “最后一公里”：不是哪个 item值更高，也不是哪个业务更该拿量，而是最终给用户的这张列表，能不能既尽量好看，又稳定满足平台必须守住的边界。

列表重排

但即使所有硬约束都满足了，问题也还没有结束。因为一张列表 “合法”，并不等于它就是 “一张好列表”。

这正是列表重排存在的原因：约束重排回答的是 “哪些列表不能出”，而列表重排回答的是 “在所有能出的列表里，哪一张最好”。

如果沿着前面的逻辑继续推，这一层之所以能改掉精排顺序，也一定是因为它拿到了前面没有被充分编码进去的增量信息。只不过这里的增量信息，不再主要是 “硬约束是否满足”，而是 item和 item 放在一起之后会发生什么。

前面几层没有真正解决的问题，是 item 和 item之间的相互作用，以及整张列表的整体质量。第一层和 item级动态权重，本质上仍然是在给单个 item打分；第二层解决的是业务之间怎么分流量；约束重排解决的是最终结果能不能满足规则。但即使这些都做对了，系统仍然可能产出一张 “每条都不差、放在一起却不太对” 的列表。

比如：

五条内容都相关、也都合规，但它们可能高度相似，连在一起就让人疲劳
两条内容单看都不错，但前一条已经满足了用户需求，后一条的边际价值会骤降
同样一组item，排在前两位和排在第五、第六位，对用户体验的影响可能完全不同
有些组合虽然没有违反任何硬规则，但在节奏、丰富度、探索感上明显更差

这些现象的关键在于：某个 item 的真实价值，已经不再是 “独立于别的 item而存在” 的了。也就是说，列表重排拿到的增量信息，往往是 “前后文关系”“相邻替代与互补”“位置对满意度的影响”“当前列表已经有多单一或多丰富” 等列表级上下文。它未必是精排完全看不到的原始特征，但往往是精排阶段没有显式建模、也没有显式求解的结构信息。

这类问题也很难被完整写成若干条硬规则，因为 “什么叫一张更好的列表” 往往是一个更软、更整体、也更依赖上下文的问题。

传统 pointwise / pairwise 学习排序，更关注单 item 或 item pair的相对顺序；而 listwise 方法直接把整张列表当成优化对象。

从学习排序的发展脉络看，FromRankNet to LambdaRank to LambdaMART: An Overview 已经系统梳理了pointwise、pairwise、listwise之间的差异。真正到了推荐系统的重排阶段，这个思想会更进一步：

既然用户消费的是最终列表，那训练目标就应该尽量贴近最终列表质量，而不是只优化某个单点surrogate loss。

一个代表性的工作是 Personalized Re-ranking forRecommendation。它在已有候选列表上，用更强的序列建模 / 自注意力结构去建模item-item 的全局关系，从而实现个性化的列表级重排。

不过严格来说，“listwise 方法”在工业实现上其实分两种形态，输入都是一张列表，但输出形式完全不同：

类型	输入	输出	典型用法
Listwise scorer/context model	候选列表	每个位置的新分数（再 argsort 出最终序）	PRM 等 contextual re-scoring
Listwise evaluator	一个完整排列 $\pi$	一个标量 $V_\phi(\pi)$，代表整张列表的整体效用	Generator-Evaluator 范式

前者隐含一个假设：好的列表 ≈ 每个位置都放上下文打分最高的item，所以它最终输出的仍是 per-itemscore。后者不做这个假设，它直接对整个排列打总分，因而能捕捉到「整体效用不可分解为各位置之和」的情形。

后者引出了一种更接近 Slate思想的工业范式 ——Generator-Evaluator：

Generator：用 beam search、autoregressive生成、或者轻量 RL policy，产出若干条候选排列
Evaluator：用一个 listwise utility模型对每条候选整体打分
最终选 $V_\phi(\pi)$最高的那一条作为输出

形式上可以写成：

\[\pi^\star \approx \arg\max_{\pi \in \text{Gen}(\mathcal{C})} V_\phi(\pi)\]

其中 $\text{Gen}(\mathcal{C})$ 是generator 在候选集 $\mathcal{C}$上展开出的有限候选排列集合。本质上，这是在用「有限搜索 +整体评估」去近似那个本来组合爆炸、不可枚举的 $\arg\max_\pi U(u,\pi)$。

这套范式刚好位于 listwise scorer 和 Slate 优化之间：比纯 scorer强（能直接优化整张列表的效用，而不只是逐位置的 contextual 分数）；比Slate / RL轻（仍以「一次性产出最终列表」为目标，不需要建模长期反馈与时序动作空间，工程落地难度低很多）。

从方法论上看，无论是 scorer 还是evaluator，这一类方法的共同关键词都是：显式建模列表上下文，并直接优化整张列表的整体质量。如果说约束重排更像是 rule-aware optimization，那么列表重排更像是objective-awareoptimization：前者更关心 “别犯错”，后者更关心 “怎样才更好”。

因此，这类方法的必要性就在这里：它解决的不是 “某条内容该不该出”，而是为什么这几条内容放在一起，会比另一种拼法更值得给用户看。

Slate 优化

比 listwise 再往前一步，是把最终列表当成一个 slate来优化。

这一层之所以还要单独拿出来讲，是因为即使做了列表重排，很多方法本质上仍然是在回答：在已有候选里，哪几条放在一起更好？但Slate优化想进一步回答的是：这个列表本身就是一个整体动作，它的价值不只是各位置效果的加总，而是会沿着用户消费过程逐步展开。

一个典型形式是：

\[U(\pi) = \sum_{t=1}^{K} g_t(u, i_{\pi_t}, \pi_{

这里，$g_t(u, i_{\pi_t},\pi_{ 表示在第 \(t$个位置上，把 item $i_{\pi_t}$接在前缀列表 $\pi_{后面时，对用户 \(u$产生的边际价值；$\pi_{表示位置 \(t$之前已经确定的前缀列表。

也就是说，第 $t$个位置的价值，不只取决于当前 item，还取决于前面已经放了什么。

这听起来和前面讲的 listwise 很像，但两者的关注点还是有差别：listwise更强调 “把整张列表作为训练和优化对象”，而 slate optimization更强调 “列表是一个有顺序、有反馈、会逐步影响后续行为的决策过程”。

它真正要补上的，是前面还没有彻底解决的两类问题：

第一类，是前序曝光会改变后续 item的真实价值。比如一条强刺激短视频先出了，后面一条风格相近的视频价值就会被明显稀释；但如果前面先放的是解释型内容，后面再接交易型内容，转化反而可能更高。

第二类，是系统开始关心的不只是这一页当下好不好，而是这页看完之后，用户接下来会怎么走。这时，当前点击已经不再是唯一目标，session深度、后续停留、后续转化，甚至用户下一次回访，都可能成为 slate的一部分价值。

所以，这类方法特别适合处理：

相似内容连出带来的疲劳
内容之间的互补与替代
不同位置的展示差异
整页体验与 session 级目标

举个更直观的例子：如果前两条内容已经把用户情绪拉得很高，第三条继续上同类强刺激内容，未必最优；这时插入一条承接型、解释型或者轻量商业化内容，整页体验反而可能更好。这个决策的关键，不再只是 “第三条自己值不值钱”，而是 “它接在前两条后面，整张slate 会变成什么样”。

从这个角度看，Slate优化的必要性在于：它不只是在做 “列表级排序”，而是在做路径级、过程级的排序决策。

Seq2Slate:Re-ranking and Slate Optimization with RNNs是这一方向很有代表性的工作。它不再把列表看成若干个独立点，而是把 “生成一个好列表” 本身看成一个序列决策问题。

如果再往长期价值走，问题会进一步演化成 reinforcement learning版本。一个很有代表性的工作是 SlateQ: A TractableDecomposition for Reinforcement Learning withSlates。它试图回答的是：

这一次怎么排，不只是影响当前点击，还会影响用户下一步、下下步的行为，那么列表该怎么优化？

从方法论上看，这一类方法的关键词是：把列表看成一个按顺序展开的决策过程，而不只是一个静态结果。

一个常见问题：改序之后，context变了，要不要重新评估？

到了第三层，一个很自然的问题是：如果重排把序改了，context也就跟着变了，那是不是又要重新打分、重新排一遍？如果继续重排，context又会再变一次，这件事会不会掉进死循环？

这个问题是真问题，而且在很多 context model 里确实会出现。比如某个item的打分里显式用了 “前面已经出现了多少个同类内容”“前一条是不是同作者”“当前列表丰富度如何” 这类特征，那么只要顺序一改，这些特征就会跟着改。

但工程上通常不会真的让它无限循环下去，因为第三层并不是在求一个 “不断重排直到世界稳定” 的抽象过程，而是在定义一个有限步、可执行的优化协议。常见做法大概有三类：

一次性重排：先基于初始候选序构造 context 特征，只rerank一次。它不追求严格全局最优，但实现简单、稳定性好，是很多工业系统的常见做法
顺序生成：按位置从前到后构造列表。每次确定下一个item 时，prefix 已经固定，因此 context 也是确定的。这其实就是 greedy /beam search / autoregressive slate generation 的典型范式
有限次迭代：先出一版列表，再基于新列表更新 context特征，然后再 rerank 1~2 轮就停。它本质上是在做近似 fixed-point求解，但必须人为限制轮数，否则收益未必增加，震荡却很容易增加

所以，严格地说，如果 context 依赖当前顺序，那么 “改序会改变context” 这件事当然成立；但这并不意味着系统一定会陷入死循环。真正的关键不在于 “要不要一直重排到完全收敛”，而在于：你到底把第三层定义成一个什么样的优化问题，以及愿意为它付出多大的计算和稳定性成本。

很多时候，工业系统并不追求一个数学上完全自洽的全局最优解，而是追求一个足够好的近似解：一次重排能带来多少收益，有限次迭代会不会更稳，顺序生成的计算成本是否可接受。这些，往往比 “理论上是否存在完美收敛点” 更重要。

当然，这也解释了为什么第三层的方法会越来越复杂：约束重排通常最稳定，因为它更多是在可行域内做有限搜索；列表重排次之，因为它开始显式依赖列表上下文；Slate优化最复杂，因为它不仅让当前列表依赖prefix，还让目标函数本身依赖后续行为和长期反馈。

延伸方向：让排序本身可微

需要先说明：可微排序并不是和前面三类（约束重排 / 列表重排 / Slate优化）并列的另一类重排方法，而是一类训练侧工具 —— 它让前面这些重排方法（尤其是listwise 和 slate）可以更直接地端到端优化” 最终列表质量”。

传统排序算子本身是离散的、不可导的，这会让很多” 真正贴近最终目标” 的优化难以直接做端到端训练。

于是就有了可微排序这一类工作，比如：

SoftSort: A ContinuousRelaxation for the argsort Operator
Differentiable Ranks andSorting using Optimal Transport

这类方法的核心目标是：

不再只是优化一个和排序相关的 surrogateloss，而是尽量让训练目标更直接贴近” 最终排序结果本身”。

它们目前更多偏研究和高阶工程场景，但非常有启发意义，因为它说明了一件事：排序这件事本身，也可以成为优化对象，而不只是模型输出之后的固定后处理。

如何判断当前应该优化的层级

这其实是这篇文章最想给出的一个判断框架。

先想第二层

各业务内部精排已经相对稳定，但彼此竞争关系混乱
某业务总觉得自己 “该出的没出”
广告、直播、电商、内容之间总在抢流量
load、预算、保量、成本约束越来越重
线上经常需要控量、提量、保穿透、保营收

这类问题的核心，不是 item选错了，而是流量没有在多业务之间分好。这时更应该优先思考calibration、multiplier、pacing、score shading 等第二层方法。

先想第三层

top-k 里单条内容都不差，但整页体验很差
同质化严重，用户容易疲劳
多样性、公平性、生态目标越来越重要
位置、相邻关系、模板结构明显影响效果
需要优化长期行为，而不是只看当前点击

这类问题的核心，不是 “流量给错了业务”，而是最终列表没有拼好。这时更应该优先考虑constrained re-ranking、listwise / slate optimization 等第三层方法。

直白总结

第一层解决：这个东西值多少钱？
第二层解决：在约束下，这次流量给谁？
第三层解决：整张列表怎么拼才最好？

这三层并不是彼此替代关系，而是一个逐层抬高优化对象的过程。

工程如何演进

很多系统的演进路径，往往不是一开始就把三层全部做到位，而是逐层往上长。

先做好第一层

如果单 item的价值预估本身就不稳定，那么后面很多复杂机制都会建立在沙地上。这个阶段的重点是把：

特征体系
标签定义
多目标建模
个性化能力

先打稳。

再引入第二层

这是很多feed、内容平台、广告混排系统最自然的一步。因为当系统开始出现：

多 source 共存
业务保量
营收和体验冲突
不同业务分数不可直接比较
预算和 pacing 需求

第二层几乎就是必需的。

这个阶段里，最先落地、最有性价比的，通常是：

score calibration
business-level personalized multiplier
pacing / score shading
平台级治理机制（锚点、统一记账、全局约束）

最后引入第三层

当系统开始强烈感受到下面这些问题时，第三层往往就必须出现：

top-k 虽然单条都不错，但整页很差
同质化严重
多样性、公平性、生态目标越来越重要
需要优化长期行为，而不是只看当前点击
列表内部的上下文关系越来越重要

这个阶段里，更常见的技术路径是：

先从 constrained re-ranking 开始（保住硬规则）
再往 listwise re-ranking / Generator-Evaluator走（显式建模列表整体效用）
更复杂的场景再考虑 slate optimization、bandit、RL

换句话说，工程里通常不是 “一上来就全量RL”，而是沿着约束更强、目标更复杂、优化对象更整体的方向逐步演进。

总结

这篇文章真正想回答的，不是 “为什么每个用户的排序权重不一样” 这种表面命题，而是：

当第一层已经能够较好学习用户对单个 item的偏好之后，平台为什么还必须引入混排层和重排层？它们分别在弥补什么，又分别在优化什么？

完整答案先用一张对照表罗列：

层级	优化对象	主要方法	这一层的增量信息	不解决（边界）
第一层个性化精排	单 item 价值 $s(u,i,x)$	单目标 / 多目标加权精排（个性化隐式学进参数）	用户 - 内容匹配	业务间流量分配；列表内部相互作用
第二层个性化混排	业务级流量分配（受约束）	分数校准 → 动态调权 → Score Shading / Pacing	业务量纲对齐；平台约束；pacing 状态	业务内部哪条更该出；列表整体组合质量
第三层全局重排	整张列表组合质量 $\pi^\star$	item 级权重 → 约束重排 → 列表重排（含 Generator-Evaluator）→Slate	列表上下文；可行域；前序 - 后序依赖；长期反馈	上游候选质量本身

把这张表压缩成两句话：

第二层不是在 “修一个不准的分数”，而是在做受约束的资源分配与在线控制 —— 因为流量本身是稀缺的、有约束的、动态的
第三层也不是 “多做一步后处理”，而是在做列表级的组合优化 —— 因为用户最终消费的是整张列表，而不是若干个彼此独立的item

这不是工程上的冗余，而是问题本身决定的。

如果后面继续展开，这篇文章真正值得深入的，也正是这两条线：

不改变精排序的个性化混排：如何通过calibration、multiplier、pacing、score shading在多业务竞争中实现可控的个性化分发
允许直接改精排序的全局重排：如何通过 listwise / slateoptimization、约束优化和长期价值建模，把个性化从单 item推进到整张列表

参考文献

Deep LandscapeForecasting for Real-time Bidding Advertising
从 Bid Shading 到 ScoreShading：混排优化的建模、控制与博弈
Personalized Re-rankingfor Recommendation
Seq2Slate:Re-ranking and Slate Optimization with RNNs
SlateQ: A TractableDecomposition for Reinforcement Learning with Slates
SoftSort: A ContinuousRelaxation for the argsort Operator
Differentiable Ranks andSorting using Optimal Transport
FromRankNet to LambdaRank to LambdaMART: An Overview

Personalized Ranking Formulas: From Item Scoring to Mixed Ranking to Global Reranking

2026-06-07T06:20:00.000Z

The “personalized ranking formula” is a recurring topic inrecommendation systems, but the term itself is often imprecise — we tendto lump together three fundamentally different problems.

More precisely, personalized ranking in a recommendation systemtypically involves at least three layers:

Layer 1: Personalized scoring (fine ranking), whichanswers “what is the value of showing this item to this user?”
Layer 2: Personalized mixed ranking (blending),which answers “when multiple business lines compete for the sameimpression slot, who should get it?”
Layer 3: Global reranking, which answers “the usersees an entire list — how should we assemble it?”

For many modern recommendation systems, Layer 1 is already strongenough.

User embeddings, item embeddings, multi-task learning, cross features— all of these aim at the same target: getting the model to accuratelypredict how valuable a (user, item) pair is. In that sense, mostproduction rankers are already personalized; that personalization justisn’t written as “one set of weights per user” — it’s been absorbedimplicitly into the model parameters.

Yet real systems exhibit something that looks contradictory at firstglance: even with a strong Layer 1, production still runs Layer 2blending, traffic control, quota management, plus Layer 3 reranking, andadditionally bolts on score calibration, pacing, shading, and listwisereranking.

The intuitive explanation is: “Layer 1 isn’t accurate enough, soLayer 2 and Layer 3 are patches.” That isn’t entirely wrong, but it’sonly half the story.

The deeper reason is that Layer 1, Layer 2, and Layer 3 are notoptimizing the same thing.

Layer 1 optimizes per-item value prediction
Layer 2 optimizes constrained traffic allocation across businesslines
Layer 3 optimizes overall list composition

For this reason, the truly interesting question about “personalizedranking formulas” is not “why are different users’ weights different”but rather: once Layer 1 can already reasonably learn a user’sper-item preferences, why does the platform still need Layer 2 mixedranking and Layer 3 global reranking? What is each layer compensatingfor, and what is each layer optimizing?

This article is about exactly that three-layer question.

Before diving into the details, here is a one-shot overview of whateach layer optimizes, its key methods, and where its boundary lies:

What Layer 1 solves

Mathematically, Layer 1 learns a scoring function:

\[s(u,i,x) = f_\theta(u,i,x)\]

where $s(u,i,x)$ is the score /predicted value produced by Layer 1, $f_\theta$ is a scoring function withparameters $\theta$; $u$ is the user, $i$ is the item, $x$ is the context, and $\theta$ are the model parameters. Thisscore essentially answers:

Given the current context, what value do we expect from showing thisitem to this user?

This value can be a single objective such as CTR, or a combination ofmultiple objectives:

\[s(u,i,x) = w_1 \cdot CTR + w_2 \cdot CVR + w_3 \cdot WatchTime + w_4\cdot GMV\]

Here $w_1, w_2, w_3, w_4$ are thefusion weights across objectives; CTR, CVR, WatchTime, and GMV stand forclick-through rate, conversion rate, watch time, and gross merchandisevalue respectively.

A sufficiently strong model can pick up deep personalizationdifferences:

Some users prefer longer dwell time
Some users are more easily converted by e-commerce content
Some users are highly ad-averse
Some new users need stable experiences; some heavy users toleratemore aggressive personalization

So, for the question “is this user a match for this item,” Layer 1already does a lot. What it’s really good at, in one sentence:

Roughly how much is this item worth to thisuser.

The catch is that recommendation systems were never solving only thatone question.

Why per-item scoring isn’tenough

If we wanted to do everything with just Layer 1, we’d need at leastfour conditions (assumptions) to hold at the same time.

These four conditions split into two groups:

Per-item additivity and scorecommensurability together determine whether the “sum-then-sort”pointwise paradigm is mathematically valid at all — they are the rootreason Layer 3 (list-level combinatorial optimization) exists
No additional global constraints and astatic environment together determine whether the problem stillcarries resource constraints and a time dimension — they are the rootreason Layer 2 (traffic allocation and online control) exists

Per-item additivity

The overall utility of the final list must satisfy:

\[U(\pi) = \sum_{k=1}^{K} v(u, i_{\pi_k}, k)\]

Here $U(\pi)$ is the total utilityof permutation $\pi$ (we suppress itsdependence on user and context for brevity). $K$ is the list length, $i_{\pi_k}$ is the item at position $k$, and $v(u,i_{\pi_k}, k)$ is the per-item value at position $k$ for user $u$. This formula already encodes a strongassumption: each item’s value depends only on the user, the itemitself, and its position — not on the other items in thelist.

But in real systems this assumption is often broken. The more commonform is:

\[U(\pi) = \sum_{k=1}^{K} v(u, i_{\pi_k}, k) + \sum_{k

where the second term $g(i_{\pi_k},i_{\pi_l}, u)$ captures the additional interaction effect of twoitems co-appearing in the same list — complementarity, substitution,fatigue, or diversity gain. For example:

Two highly similar videos shown back-to-back: the second one is muchless engaging
Too much of the same kind of content in a row: users get fatiguedfaster
Interleaving articles, short videos, and live streams: userstypically stay engaged longer than with a single format
Different positions suit different content — eye-catching items workat the top, follow-on content works further down
When users look at an entire page, they perceive not just per-itemquality but also how varied and fresh the page is, and how well itmatches their current context

Once this interaction term exists, pointwise per-item scoring is nolonger sufficient to derive the optimal final list.

Score commensurability

This condition is also almost never satisfied in practice.

Scores from different business lines, different models, and differentobjectives typically don’t share a common scale:

0.4 from the article ranker
0.2 from the live-streaming ranker
An eCPM from ads
A GMV estimate from e-commerce

These scores come from different training objectives, sampledistributions, noise levels, and business semantics. Even if they all“look like a number,” that doesn’t mean they can be directlycompared.

So Layer 1 can’t fully nail down per-item value, and multi-objectivescores can’t easily be made commensurable — both are important reasonswhy Layers 2 and 3 exist.

But that’s not the whole story.

No additional globalconstraints

If the only goal were to maximize a single unified utility, Layer 1alone really could do most of the work.

But real recommendation systems usually come with many constraintsthat act on the overall result:

Load constraints from monetization-style business lines (ads,e-commerce, live streaming) — these are really LT-based but oftenexpressed as load
Marketing-mix de-clustering (e.g., no two consecutive monetizationitems)
Diversity
Author / merchant fairness
Platform ecosystem balance
…

These constraints don’t act on any single item; they act on theentire list, the entire time window, or even the entire traffic pool. Sono matter how accurate a single item’s score is, that alone doesn’tsatisfy these constraints automatically.

A static environment

If the traffic environment were static, ranking would be muchsimpler.

But real systems live in a continuously changing dynamicenvironment:

Has a particular business line already over-served this hour?
Has the user already grown tired?
Should we preserve some exploration traffic right now?
Has supply of a certain content type suddenly dropped?

By this point the problem is no longer just “ranking” — it’s adynamic decision problem with a strong flavor of control.

So a real recommendation system is not solving a static “score eachitem then sort” problem. It’s solving a dynamic systems problem:allocating traffic under constraints, assembling lists, andkeeping the system stable.

That is why, even with a strong Layer 1, Layers 2 and 3 cannot beomitted.

Layer2’s responsibility: allocating traffic across business lines

In many recommendation systems, the entities competing forimpressions are not a single content source but multiple business linescompeting for the same impression slot:

Articles
Short videos
Live streams
E-commerce cards
Ads
Local life content

Each business line typically has its own retrieval, pre-ranking, andranking pipeline, each capable of answering “within my queue, which itemis best.” But the question the platform really needs to answer is not“which item is best within this business” — it’s “for this specificimpression slot, which business line should win?”

This is no longer a per-item value-prediction problem. It’s a classiccross-business resource allocation problem.

And this problem usually comes with a stack of platform constraintsby default:

Some business has a penetration target
Some business’s load cannot drop too far
Ads must stay below a cap
The platform doesn’t want any single content type to crowd out theothers long-term
Some business’s user experience is already strained
Some business has limited server or supply capacity at themoment
Some business’s ranker scores don’t translate directly to ahead-to-head comparison with another business

At this point, the problem the platform really faces looks more likethe following, where $\text{MixUtility}$ is the overall utilitythe blending layer wants to maximize, and $\text{Load}, \text{Budget}, \text{Quota},\text{Risk}, \text{Fairness}$ are platform constraints ontraffic share, budget, quota, risk, and fairness:

\[\begin{aligned}\max \quad & \text{MixUtility} \\\text{s.t.} \quad &\text{Load},\text{Budget},\text{Quota},\text{Risk},\text{Fairness}\end{aligned}\]

At this point, no matter how well Layer 1 predicts per-item value, itcannot answer “how should traffic be allocated” on its own.

The platform still needs an additional decision layer to handle:

How to calibrate scores across business lines
Given current budget and targets, which business line is the betterrecipient of this impression
Whether a given business should bid up, bid down, hold supply, orlimit supply
How to balance local utility against system-wide stability

That is the reason Layer 2 (mixed ranking / blending) exists.

A concrete example:

Suppose a user clearly prefers live streams over articles. The mostnatural reaction is to globally bump up the weight on live streams inthe blending layer.

This often works, because it’s solving exactly the right question:should this impression come from the live-streaming queue or the articlequeue?

But there is a boundary that must be made explicit: Layer 2can only decide “who gets the traffic”; it cannot decide “which itemwithin that business should be served.”

If the top-1 inside the live-streaming queue happens to be ahard-sell live commerce stream while the user actually likes “casualknowledge-sharing live streams,” then no matter how much the blendinglayer boosts the live-stream weight, all it does is repeatedly pushthe wrong kind of live stream at the user. So while Layer 2 isnecessary, it has a natural ceiling: it is more like abusiness-level scheduler than a per-item selector.

Treating each business as an already-sorted queue, what Layer 2 doesbecomes very intuitive:

Don’t change the internal order of any queue
For each slot, decide which queue to pull the next card from

In other words, Layer 2 doesn’t optimize per item; it optimizes abusiness-level / source-level traffic schedulingpolicy.

A common misconception: isn’t Layer 2 essentially each participantadjusting its own weights so everyone’s scores end up commensurable?

That’s only half the answer.

Layer 2 does include “making different business lines’ scores roughlycomparable,” but that’s only the starting point, not the whole of it.More completely, Layer 2 does two things:

First, map each participant’s local value into a roughly competitiveshared space
Then, on that shared space, do constrained dynamic trafficallocation given platform constraints, budget state, and traffictargets

So score commensurability is more like Layer 2’s entryticket, while constrained resource allocation is the actual main problemof Layer 2.

From this angle, all of the following methods sit in Layer 2:

Score calibration
Personalized multiplier
Quota / pacing
Score-shading / bid-shading-style dynamic score adjustment
Various constrained order-preserving blending schemes

So Layer 2 isn’t just patching up “inaccurate ranker scores.” It addsa new layer of capability to the platform:

Constrained, dynamic, personalized traffic control on top ofthe existing per-business rankers, without touching their internalorder.

Layer2’s methods: personalized mixed ranking that preserves per-businessorder

We’ve covered why Layer 2 must exist. Now let’s look athow — what its mainstream methods actually are.

Score calibration

This is the most overlooked, yet most engineering-critical, step.

Scores from different business lines are rarely on the samescale:

0.4 from the article ranker
0.2 from the live-streaming ranker
15 from ad eCPM
Some normalized value of GMV from e-commerce

Comparing these scores directly is usually meaningless, because theirunderlying model objectives, sample distributions, training procedures,and business semantics all differ.

So before any real personalized blending, the platform usually does acalibration step, including:

Bucketed calibration
Quantile normalization
Platt scaling / isotonic regression
Conditional calibration by user segment or scene

Or, in the simplest case, just pick a fixed coefficient per businessfrom average scale ratios over a recent window. The essence of this stepis: first solve “can we even compare these,” then solve “how todivide them up.”

Without calibration, the downstream personalized multipliers, pacing,and shading will all be distorted.

Dynamic weighting

Once different business lines’ scores are roughly comparable, themost direct approach is to apply a dynamic weight at the businesslevel:

\[\text{MixScore}_{u,b} = \alpha_{u,b}(x) \cdot \text{CalibScore}_b\]

where:

$\text{MixScore}_{u,b}$ is themixed-ranking score for user $u$ andbusiness $b$ on the currentrequest
$\text{CalibScore}_b$ is thecalibrated comparable base score for business $b$
$b$ indexes business /source
$\alpha_{u,b}(x)$ is user $u$’s preference weight for business $b$ under context $x$

For example:

Users who prefer live streams get a higher multiplier on thelive-stream source
Users who prefer articles get a higher article multiplier
Some contexts favor short videos, some favor e-commerce cards

This approach is simple, intuitive, interpretable, and fits naturallyon top of any existing multi-business stack. It is fundamentallyorder-preserving blending — it only adjustsinter-business competitiveness without changing intra-businessorder.

But its ceiling is just as clear: it can only answer “whogets this traffic,” not “which item within that business should beserved.”

ScoreShading / Pacing: viewing blending as constrained dynamic bidding

Going one step further, platforms realize that user preferenceweights alone are not enough — many problems aren’t really about“preference” but about “in the current constraint state, is this trafficslot worth winning?”

A natural framing here is to view a business’s blending score as animplicit bid.

If bid shading in ads solves:

In a first-price auction, how do we cut cost and lift ROI withoutlosing the ability to win volume?

then score shading in blending solves:

Without changing intra-business order, how do we dynamically adjust abusiness’s PK score to find a better balance among penetration, cost,and stability?

For a given business, the problem can be written as:

\[\begin{aligned}\max_{s_i} \quad & \sum_i V_i F(s_i) \\\text{s.t.} \quad & \frac{1}{n}\sum_i s_i F(s_i)\le C\end{aligned}\]

where:

$V_i$: the value this businessgets if it wins opportunity $i$
$s_i$: this business’s blendingscore / PK score on opportunity $i$
$F(s_i)$: the win rate at score$s_i$
$n$: the number of opportunities/ samples in the statistics window
$C$: the cost or scaleconstraint

By Lagrangian duality, this can be turned into a per-request decisionproblem:

\[s_i^\star = \arg\max_{s_i} F(s_i) \left( V_i - \lambda s_i \right)\]

Here $\lambda$ is strictly theLagrange multiplier on the cost constraint (i.e., a shadow price); inproduction it is typically tracked online by a pacing controller(PID/EMA, etc.) such that the long-run average cost stays close to $C$. $s_i^\star$ is the optimal blending / PKscore for opportunity $i$.

This formula is representative because it makes one thing concrete:Layer 2 is not “fixing an inaccurate score” — it is solving aconstrained online-control problem.

The hardest step in this method isn’t the formula itself butthe win-rate model $F(s)$. Intuitively, tworoutes:

Point estimate: directly model $P(\text{win}=1|s,\text{context})$, theprobability of winning given score $s$ and context
Distribution estimate: don’t model the win ratedirectly; instead model the distribution of competitors’ top score, thenderive the win rate from that distribution

The former is more intuitive; the latter is more complete.

A representative work here is Deep Landscape Forecasting forReal-time Bidding Advertising. Instead of learning “will I win atthis bid,” it learns the competition landscape’s distributionparameters, from which the win rate at any bid can be derivedanalytically. The same idea transfers cleanly to blending: if you reallywant score shading to work, you often need not “win/no-win at thisscore” but “what does the entire competitive environment look like rightnow.”

Score shading is great for efficiency, but without governance iteasily turns local optimization into global risk.

If every business is allowed to shade on its own, two failure modesshow up quickly:

(1) Score deflation

Every business tries to “win with a lower score.” Over time, thesystem’s absolute score range drifts leftward, eventually breaking anystrategy that depends on absolute-value thresholds.

(2) Control oscillation

When multiple businesses simultaneously run their own PID / pacingcontrollers, they all interact in the same shared traffic pool and formcoupled oscillations. The most common symptom: one minute live streamstake too much volume, the next minute short videos over-compensate, andthe whole platform develops high-frequency jitter.

So in production, score shading is not just a modeling problem; it’sa platform-mechanism problem. At least one of the following governancestrategies is usually needed:

Global anchor: tie the system to a relativelystable value baseline
Unified accounting mechanism: competition is judgednot just by “who reports a higher score” but by “who actuallycontributes more global value”

For more details on Score Shading, see: From Bid Shading to Score Shading:Modeling, Control, and Game Dynamics in Mixed RankingOptimization

Layer 3’sresponsibility: assembling the entire list

If Layer 2 is mainly solving “who gets the traffic,” Layer 3 issolving a more fundamental problem: the user doesn’t consume a singleitem; the user consumes an entire list.

In Layer 2, the system mostly answers: which business /source gets this slot first. Its core objects areinter-business competition and traffic allocation; even with quota,pacing, and load constraints, what gets solved is usuallybusiness-level, time-window-level, or resource-share-level.

In Layer 3, the question shifts. The system now has to answer: how dowe actually assemble the final list shown to the user?

That is the most fundamental difference between Layer 2 and Layer 3:Layer 2 decides “who gets the volume first,” while Layer 3 decides “whatthis list itself looks like.” The former manages inter-sourcecompetition; the latter directly faces top-k ordering, positions,context, and combinatorial quality.

That sentence sounds ordinary, but it implies something important:per-item optimality is not the same as list optimality.

Layer 1’s default logic is usually: higher score, higher rank. Thatlogic implicitly assumes: total list value = simple sum ofper-item values.

In reality, that assumption is often violated.

The clearest example is content fatigue. Suppose a user’s top-4candidates are scored:

Video A: 0.90
Video B: 0.88
Video C: 0.87
Article D: 0.80

Sorting by score puts three very similar videos in a row. Each itemalone looks great, but the combination might not. Swapping the third forArticle D could yield a better overall page satisfaction.

This shows: even with very accurate per-item scoring, greedypointwise sorting does not guarantee a globally optimal top-klist.

This is the root reason Layer 3 exists.

It no longer solves “what is this item worth”; it solves: howshould this list be assembled so the overall result is best?

Layer3’s methods: global reranking that may directly change the per-itemorder

In Layer 3, the optimization object is no longer “which business winsthis impression” but the entire permutation:

\[\pi^\star=\arg\max_{\pi} U(u,\pi)\]

where $U(u,\pi)$ is the totalutility of permutation $\pi$ for user$u$; $\pi$ is the final list, and $\pi^\star$ is the list that maximizes theobjective.

What the system actually cares about here:

top-k overall experience
Item-item substitution and complementarity
Diversity
Position bias
Fairness
Long-term value

So this layer’s methods are significantly more complex than Layer2’s. Before diving in, here is a high-level map. Layer 3 contains atleast two steps:

Define each item’s utility more reasonably.Item-level personalized weights live here; they answer “how much is thissingle piece of content worth”
Optimize the final list more reasonably.Constrained reranking, listwise reranking, and slate optimization livehere; they answer “given these items, how should the list be puttogether”

By analogy, item-level personalized weights are like deciding “whateach brick is worth”; the other three are like deciding “how to laythese bricks into a wall.”

Continuing this decomposition, the second step further splits intothree classes, from “hard rules” to “soft quality” to “temporallong-term value”:

Constrained reranking: first answers “which listsmust not be served”
Listwise reranking: then answers “among the liststhat can be served, which is best”
Slate optimization: further answers “this list notonly affects the current page but continues to shape downstream userbehavior”

Each is covered below.

Item-level personalizedweights

A boundary note first: strictly speaking, item-level personalizedweights sit on the boundary between Layer 1 and Layer3. We put them in Layer 3 here because only when they exist as“an extra utility-adjustment step after the ranker” do theybelong to Layer 3; if folded directly into the ranker, they remain Layer1. The discussion below assumes the former.

The most common — and most easily productionized — method heredirectly models item-level utility:

\[U(u,i,x) = \sum_k w_k(u, x)\,\phi_k(i, x)\]

where:

$U(u,i,x)$ is the utility of item$i$ to user $u$ under context $x$
$\phi_k(i,x)$ is item $i$’s signal or predicted value on the$k$-th objective under context $x$ — CTR, CVR, GMV, dwell time, retention,business value, etc.
$w_k(u,x)$ is a dynamic weightthat depends on user and context
$k$ indexes the differentobjectives

Formally, this looks similar to Layer 2’s business multiplier — bothare “weight × score” — but they act on completely different objects:Layer 2’s multiplier acts on the source / businesslevel and decides “which business gets this traffic,” withintra-business order unchanged; the weight here acts on the itemlevel and decides “what this single item is worth,” so it candirectly change the order among items.

The deeper point this method is making: when multi-objectivetrade-offs vary with user and scene, the system can either absorb thatvariation implicitly into one shared scoring function, or expose itexplicitly as item-level dynamic weights. As long as the modelhas enough capacity and the features cover user state and context, ashared parameter set can in principle learn the “weekday commutevs. weekend evening” difference too.

If we use one black-box model, we can still write $U(u,i,x)=f_\theta(u,i,x)$; thepersonalized multi-objective trade-off is hidden inside the black-boxutility function. If we write $U(u,i,x)=\sum_k w_k(u,x)\phi_k(i,x)$, thesystem is explicitly modeling “do we currently care more about CTR, GMV,dwell time, or retention?”

In plain terms: this is not really about “can a single set ofparameters do this” — it’s about “should the internal yardstick stayfixed across different users and different moments?” For example:

For a high-spend user, GMV / CVR within a commerce content piece maymatter more; for a casual entertainment user, dwell time, completion,and low-cost enjoyment may matter more
For new users, the system may weigh retention, stable experience,and low intrusion more heavily; for heavy users, it may push moreaggressive personalization, clicks, and conversion
Even the same user has different value weights for weekday commute,weekday evening, and weekend leisure: sometimes more efficiency-driven,sometimes more relaxation-driven, sometimes more purchase-driven

So the value of explicit dynamic weights is often not “a black-boxcan’t do it” but that they offer stronger controllability,interpretability, and engineering decomposability.

There are many ways to learn these weights. In industry, three commonfamilies: supervised end-to-end fusion,contextual bandit, and actor-critic.They appear to learn the same weight function $w_k(u, x)$, but they actually answer threedifferent questions:

Method	What question it answers	Feedback structure	Models “action affects future”?	Optimization target
Supervised end-to-end fusion	From historical logs, which $w_k$produces the best final list metric?	(context, label) static pair	No	Offline loss (proxy of the final metric)
Contextual Bandit	For this impression, which $w_k$gives the highest single-step reward? And how toexplore new combinations?	(context, action, reward) single-step	No	Single-step immediate reward
Actor-Critic	This action affects user’s future state — which $w_k$ maximizes long-termcumulative reward?	$(s, a, r, s')$ sequence	Yes	$\sum_t \gamma^t r_t$

In plain terms:

Supervised end-to-end is like looking at the answersheet after the test: take a year of logs as training data and let themodel directly approximate the “final metric.” Simple and stable, but itcan only interpolate within the observed data distribution — any $w_k$ combination not in the logs is ablind spot
Contextual Bandit is like guessing which die isbest before each roll, and immediately adjusting after seeing theresult. The key difference from supervised: it actively explores. Thekey difference from RL: it assumes each decision is independent,ignoring how the current action shifts the next request’s userstate
Actor-Critic treats recommendation as an MDP: thecurrent choice changes downstream user behavior; the Critic estimates“how much reward we can still collect starting from this state,” andback-propagates that signal into the Actor. The substantive newingredient is acknowledging that actions change thefuture, at the cost of needing a stable dense-reward signal anddealing with high variance and distribution drift

In practice, these three are not substitutes; production stacksfrequently layer them together: a supervised modellearns a baseline $w_k$; a contextualbandit explores on a small slice of traffic; an actor-critic optimizeslonger-horizon, cumulative goals (LTV, session retention) — withoutreplacing the immediate-reward target the supervised model alreadylearns.

Below we zoom in on actor-critic’s actual industrial profile — themost controversial and most easily misrepresented of the three.

A fairly common practice is to use Actor-Critic /DDPG to directly learn $w_k(u,x)$: the Actor outputs the multi-objective weights for $(u, x)$, the Critic evaluates the overallutility of the current impression / list, and the reward is set towatch time, completion rate, interaction signals,etc.

In short-video and live-streaming products — where feedback is denseand immediate — this pipeline really does work: every impressiondelivers dense reward, return signals are fast, the Critic actuallylearns, and the Actor receives a stable gradient. Kuaishou, ByteDance,Alibaba, and other content / e-commerce platforms all have public orsemi-public practice along these lines. But for RL to land at this step,at least two prerequisites must hold:

Reward must be dense enough and timely enough:watch time, completion, dwell are available on every impression withclear attribution. If switched to conversion, retention, repeatpurchase (sparse, delayed signals), off-policy evaluation andattribution stability both degrade fast
The Critic actually has to learn the list / impression-levelutility: otherwise the Actor’s weights easily over-optimize asingle metric (e.g., dwell time inflated, interaction sacrificed),breaking multi-objective balance

If the business’s primary feedback is itself sparse or delayed(clicks-to-conversion in e-commerce, long-horizon retention, etc.), thensupervised end-to-end fusion or rule +segment-based weights is still the more cost-effective choice;contextual bandit sits in between and works well as anonline-exploration supplement.

The next three sections move to the second step — “given these items,how do we put them together.”

Constrained reranking

In many businesses, the platform doesn’t merely “hope” certainconditions hold; it must enforce them. For example:

Upper bound on ad load
Minimum exposure for certain author types
Upper bound on risky content
Per-business quota
Category-coverage requirements

This layer is necessary precisely because Layer 2, while handlingsome constraints at the business level, never actually solves “can thisspecific page be served the way it’s currently laid out?”

For example, if the platform requires top-10 to have at most 2 ads,no same-author content back-to-back, and at least 1 slot reserved for acertain content type, then:

Layer 1 might give all 3 ads very high scores
Layer 2 might already keep the ad business’s overall traffic withinbudget
But on a particular request and a particular top-k, the system canstill violate the rules

So why is it that this layer can change the order produced by earlierlayers? Not because it has some mysterious new feature, but because itpushes constraints that earlier layers only handled at coarse business /time-window granularity down to the single-request, final-listlevel to be solved explicitly.

In other words, the incremental information constrained rerankingactually receives is not “this item has one more feature” but rather“what’s already in this list, how many slots are left, and whichconstraints are close to being violated.” That information is onlycomplete at the list-assembly stage.

Simple penalty or multiplier terms are usually not enough here: theyonly “lean” the result and can’t reliably guarantee a constraint holds.Too small, the constraint slips; too large, you crush overall relevance.Worse, many constraints are discrete, position-dependent, and tightlycoupled — naturally not expressible as smooth additions to a singlescore.

A more natural formulation is:

\[\begin{aligned}\max_{\pi} \quad & U(\pi) \\\text{s.t.} \quad & C_j(\pi) \le 0\end{aligned}\]

where $C_j(\pi)$ measures how muchpermutation $\pi$ violates the $j$-th constraint; $C_j(\pi) \le 0$ means the constraint issatisfied.

The core idea of constrained reranking is not “tweak the score a bitmore” but explicitly recognize: the final ranking is not a purerelevance-maximization problem but a combinatorial optimizationproblem with hard constraints.

Industry practice ranges from rule-aware greedy / swap, to moreexplicit constraint solvers like Lagrangian relaxation, min-cost flow,or ILP. The form varies; the essence is the same.

So what constrained reranking really fills in is the “last mile” thatearlier layers don’t solve: not which item is worth more, not whichbusiness should get the volume, but whether the final list shownto the user can look good while still satisfying the boundaries theplatform must hold.

Listwise reranking

Even when every hard constraint is satisfied, the story isn’t over: alist being “legal” doesn’t mean it’s a “good list.”

That’s exactly why listwise reranking exists: constrainedreranking answers “which lists must not be served”; listwise rerankinganswers “among the legal lists, which is best.”

If we continue the previous logic, this layer can also change theper-item order only because it gains incremental information thatearlier layers don’t have. Here that information isn’t mainly “are hardconstraints satisfied” but what happens when items are placedtogether.

The real unsolved problem from earlier layers is item-iteminteraction and the overall quality of the list. Layer 1 anditem-level dynamic weights are still scoring single items; Layer 2handles inter-business traffic allocation; constrained reranking handleswhether the result satisfies rules. Even with all of those done right,the system can still produce a list where “every item is decent, buttogether they don’t quite work.”

For example:

Five items are all relevant and compliant, but they’re highlysimilar — running them together causes fatigue
Two items each look fine alone, but once the first one satisfies theuser’s intent, the second’s marginal value drops sharply
The same set of items in positions 1–2 vs. positions 5–6 can producea totally different user experience
Some combinations break no rules but are clearly worse in pacing,richness, or sense of exploration

The point is: an item’s true value is no longer “independent of theother items.” The incremental information listwise reranking gains isoften things like “context relationships,” “neighboring substitution andcomplementarity,” “position’s effect on satisfaction,” “how monotonic orhow varied the current list is” — list-level context. These featuresaren’t necessarily invisible to the ranker, but they’re often notexplicitly modeled and not explicitly optimized during theranking stage.

These problems are also hard to write out completely as a set of hardrules, because “what makes a list better” tends to be a soft, holistic,context-dependent question.

Traditional pointwise / pairwise learning-to-rank focuses on singleitems or item pairs; listwise methods take the entire list as theoptimization object directly.

FromRankNet to LambdaRank to LambdaMART: An Overview systematically laysout the differences among pointwise, pairwise, and listwise. Inrecommendation reranking, the idea is pushed further:

If the user consumes the final list, the training objective should beas close to “final list quality” as possible, not just a singlepointwise surrogate.

A representative work is Personalized Re-ranking forRecommendation. It applies stronger sequence modeling /self-attention on top of an existing candidate list to model item-itemglobal relations, achieving personalized list-level reranking.

Strictly speaking, “listwise methods” come in two industrial flavors.Both take a list as input, but their outputs are quite different:

Type	Input	Output	Typical use
Listwise scorer / context model	Candidate list	A new score per position (then argsort)	PRM-style contextual re-scoring
Listwise evaluator	A full permutation $\pi$	A scalar $V_\phi(\pi)$ — thelist’s overall utility	Generator-Evaluator paradigm

The former implicitly assumes: a good list ≈ placing thecontextually-highest-scored item at each position, so the output isstill a per-item score. The latter does not assume this; it scores theentire permutation, so it can capture cases where“overall utility is not decomposable into per-position sums.”

The latter leads to a more Slate-flavored industrial paradigm —Generator-Evaluator:

Generator: uses beam search, autoregressivegeneration, or a lightweight RL policy to produce a few candidatepermutations
Evaluator: a listwise utility model gives eachcandidate an overall score
The one with the highest $V_\phi(\pi)$ is chosen

Formally:

\[\pi^\star \approx \arg\max_{\pi \in \text{Gen}(\mathcal{C})} V_\phi(\pi)\]

where $\text{Gen}(\mathcal{C})$ isthe finite set of candidate permutations the generator expands fromcandidate pool $\mathcal{C}$. Inessence, this is using “bounded search + holistic evaluation” toapproximate the otherwise combinatorial $\arg\max_\pi U(u,\pi)$.

This paradigm sits exactly between listwise scorer and slateoptimization: stronger than a pure scorer (it directly optimizes thelist’s overall utility, not just per-position contextual scores), butlighter than slate / RL (it still aims to “produce the final list in oneshot” and doesn’t need to model long-horizon feedback or temporal actionspaces — far easier to ship).

Methodologically, whether scorer or evaluator, the shared keyword forthis family is: explicitly model list context and directlyoptimize the list’s overall quality. If constrained rerankingis rule-aware optimization, listwise reranking is objective-awareoptimization: the former cares about “don’t break things”; the lattercares about “how to make it better.”

So the necessity of this family is exactly here: it doesn’t solve“should this item be served”; it solves why these items togetherare better than another arrangement.

Slate optimization

One step further beyond listwise: treat the final list as aslate.

This layer deserves its own section because, even after listwisereranking, many methods are still answering: given the candidates, whichsubset placed together is better? Slate optimization wants to go furtherand answer: the list itself is one integrated action; its valueis not just the sum of per-position effects but unfolds along the user’sconsumption process.

A typical formulation:

\[U(\pi) = \sum_{t=1}^{K} g_t(u, i_{\pi_t}, \pi_{

where $g_t(u, i_{\pi_t},\pi_{ is the marginal value at position \(t$ when item $i_{\pi_t}$ is appended after the prefix$\pi_{; \(\pi_{ is the already-determinedprefix before position \(t$.

That is, the value at position $t$depends not only on the current item but also on what has already beenplaced before it.

This sounds similar to listwise, but the focus differs: listwiseemphasizes “treat the list as the training and optimization object”;slate optimization emphasizes “the list is a sequential,feedback-bearing process that incrementally shapes downstreambehavior.”

What it really fills in is two problem types that earlier methodsdon’t fully resolve:

First, earlier impressions change the actual value of lateritems. If a high-stimulus short video plays first, asimilar-style follow-up loses much of its appeal; but if an explanatorypiece comes first and a transactional piece follows, conversion mightactually go up.

Second, the system starts caring not just about this pagebeing good, but about where the user goes after this page. Thecurrent click is no longer the only goal; session depth, subsequentdwell, downstream conversion, even the next-visit retention can allbecome part of the slate’s value.

So this family is especially well-suited to:

Fatigue from consecutively similar content
Inter-content complementarity and substitution
Display differences across positions
Whole-page experience and session-level goals

A concrete illustration: if the first two items have already liftedthe user’s emotional engagement, putting yet another high-stimulus itemin the third slot may not be optimal; inserting a follow-on,explanatory, or light commercial item might give a better page-levelexperience. The decision here isn’t “is this third item alone worth it”but “given the first two, what does the whole slate become.”

From this angle, slate optimization’s necessity is: it’s not justdoing “list-level ranking” — it’s doing path-level,process-level ranking decisions.

Seq2Slate:Re-ranking and Slate Optimization with RNNs is a representative workhere. Instead of treating the list as independent points, it treats“generating a good list” itself as a sequence decision problem.

Pushed further toward long-term value, the problem evolves into areinforcement-learning version. A representative work is SlateQ: A TractableDecomposition for Reinforcement Learning with Slates. It tries toanswer:

How we rank this time affects not just the current click but also theuser’s next step and the step after that — so how should the list beoptimized?

Methodologically, the keyword for this family is: treat thelist as a sequentially unfolding decision process, not a staticresult.

Acommon question: once the order changes, the context changes too —should we re-evaluate?

In Layer 3, a natural question arises: if reranking changes theorder, the context changes too — should we re-score and re-sort? And ifwe rerank again, the context changes again — won’t this become aninfinite loop?

The question is real, and in many context models it really doeshappen. If an item’s score depends on features like “how manysame-category items have already appeared,” “is the previous item fromthe same author,” “how diverse is the current list,” then any reordertriggers a feature change.

In practice, this is not allowed to spin forever — Layer 3 is notsolving the abstract problem of “rerank until the world stops moving”;it is defining a finite-step, executable optimizationprotocol. Three common patterns:

One-pass rerank: build context features from theinitial candidate order and rerank exactly once. It doesn’t pursuestrict global optimality, but it’s simple, stable, and the most commonchoice in production
Sequential generation: build the list position byposition; once the next item is decided, the prefix is fixed and thecontext is determined. This is the canonical pattern of greedy / beamsearch / autoregressive slate generation
Finite-iteration: produce a list, then updatecontext features based on the new list, then rerank for 1–2 rounds andstop. It’s effectively approximate fixed-point solving, but theiteration count must be capped — otherwise gains plateau whileoscillation rises

Strictly speaking, if the context depends on the current order, then“changing the order changes the context” is indeed true. But thatdoesn’t doom the system to an infinite loop. The real question isn’t“should we rerank until convergence” but: how do you define the Layer 3optimization problem, and how much computation and stability cost areyou willing to pay for it.

In many cases, industrial systems don’t pursue amathematically self-consistent global optimum; they pursue a good-enoughapproximation: how much gain does one rerank pass deliver, will a finitenumber of iterations be more stable, is the compute cost of sequentialgeneration acceptable. These usually matter more than “does a perfectfixed point exist in theory.”

That also explains why Layer 3 methods get progressively morecomplex: constrained reranking is usually the most stable because itlargely searches within a feasible region; listwise reranking next,because it begins to depend explicitly on list context; slateoptimization is the most complex, because it makes the current listdepend on the prefix and makes the objective depend ondownstream behavior and long-term feedback.

Extension:making ranking itself differentiable

A clarification first: differentiable ranking is not anothermethod on par with the three classes above (constrained / listwise /slate). It is a training-side tool — it lets thosemethods (especially listwise and slate) optimize “final list quality”more directly and more end-to-end.

Traditional sort operators are discrete and non-differentiable, whichmakes a lot of “really-close-to-final-objective” optimizations hard totrain end-to-end.

So we have differentiable ranking work like:

SoftSort: A ContinuousRelaxation for the argsort Operator
Differentiable Ranks andSorting using Optimal Transport

The core goal:

Stop optimizing only ranking-related surrogate losses; bring thetraining target as close as possible to “the final ranking resultitself.”

These methods are still mostly research-leaning and used in advancedengineering scenarios, but their lesson is clear: ranking itselfcan become an optimization object, not just a fixed post-process afterthe model.

How to decide which layerto optimize

This is the decision framework this article most wants to leavebehind.

Think Layer 2 first

Per-business rankers are relatively stable, but inter-businesscompetition is messy
A particular business often feels it “should have served more butdidn’t”
Ads, live streams, e-commerce, and content keep stealing trafficfrom each other
Load, budget, volume guarantees, and cost constraints becomeheavier
Production frequently needs to cap, lift, or stabilize a business’svolume

The core issue here is not “the wrong item got chosen” buttraffic is not well allocated across business lines.Calibration, multiplier, pacing, and score shading — Layer 2 methods —should be the first thing to consider.

Think Layer 3 first

Each item in top-k looks decent, but the page experience is bad
Homogenization is severe; users fatigue quickly
Diversity, fairness, ecosystem goals are increasingly important
Position, neighbor relations, template structure clearly affectperformance
Need to optimize long-term behavior, not just current clicks

The core issue here is not “wrong business got the traffic” butthe final list isn’t well assembled. Constrainedreranking, listwise / slate optimization — Layer 3 methods — should bethe first thing to consider.

In short

Layer 1 solves: How much is this item worth?
Layer 2 solves: Under constraints, which business gets thistraffic?
Layer 3 solves: How should this entire list beassembled?

These three layers are not substitutes. They are a process ofprogressively lifting the optimization object.

How systems evolve inpractice

Most systems don’t build all three layers at once. They grow upward,layer by layer.

First, nail Layer 1

If per-item value estimation is unstable, every complex mechanismdownstream will be built on sand. At this stage the priorities are:

Feature system
Label definition
Multi-objective modeling
Personalization capability

Get these solid first.

Then introduce Layer 2

This is the most natural next step for feeds, content platforms, andad-blending systems. Layer 2 becomes essentially mandatory once thesystem starts to show:

Multiple coexisting sources
Business-level volume guarantees
Conflict between revenue and user experience
Scores from different businesses not directly comparable
Budget and pacing requirements

The most cost-effective, first-to-ship things at this stage aretypically:

Score calibration
Business-level personalized multipliers
Pacing / score shading
Platform-level governance (anchors, unified accounting, globalconstraints)

Finally, introduce Layer 3

Layer 3 becomes necessary when the system strongly starts feelingthese pain points:

Each item in top-k is decent, but the page is bad
Severe homogenization
Diversity, fairness, ecosystem goals are increasingly important
Need to optimize long-term behavior, not just current clicks
List-internal context becomes increasingly important

A common technical path at this stage:

Start with constrained reranking (lock in hard rules)
Move to listwise reranking / Generator-Evaluator (explicitly modellist-level utility)
For more complex scenarios, consider slate optimization, bandit,RL

In other words, in engineering practice we usually don’t go “all-inon RL from day one.” We evolve in the direction of strongerconstraints, more complex objectives, more holistic optimizationobjects.

Summary

What this article really wants to answer is not the surface-level“why are different users’ weights different,” but:

Once Layer 1 can already reasonably learn a user’s per-itempreferences, why does the platform still need the blending layer and thereranking layer? What is each compensating for, and what is eachoptimizing?

The full answer fits in a comparison table:

Layer	Optimization object	Main methods	Incremental information this layer adds	What it doesn’t solve (boundary)
Layer 1 Personalized scoring	Per-item value $s(u,i,x)$	Single-objective / multi-objective weighted scoring (personalizationimplicitly learned into parameters)	User-content match	Inter-business traffic allocation; intra-list interactions
Layer 2 Personalized mixed ranking	Constrained business-level traffic allocation	Score calibration → dynamic weighting → Score Shading / Pacing	Cross-business commensurability; platform constraints; pacingstate	Which item to serve inside a business; overall list compositionquality
Layer 3 Global reranking	Overall list composition $\pi^\star$	Item-level weights → constrained reranking → listwise reranking(incl. Generator-Evaluator) → Slate	List context; feasible region; prefix-suffix dependence; long-termfeedback	Quality of the upstream candidate pool itself

Compressed into two sentences:

Layer 2 is not “patching up an inaccurate score” —it is doing constrained resource allocation and onlinecontrol, because traffic itself is scarce, constrained, anddynamic
Layer 3 is not “doing one more post-processingstep” — it is doing list-level combinatorialoptimization, because the user consumes an entire list, not aset of independent items

This is not engineering redundancy; it is what the problem itselfdemands.

If we keep going further, the two threads worth digging deeper areexactly:

Personalized mixed ranking that preserves per-itemorder: how to deliver controllable personalized distributionunder multi-business competition via calibration, multiplier, pacing,and score shading
Global reranking that may directly change the per-itemorder: how to push personalization from single items to theentire list via listwise / slate optimization, constrained optimization,and long-term value modeling

References

Deep LandscapeForecasting for Real-time Bidding Advertising
From Bid Shading to ScoreShading: Modeling, Control, and Game Dynamics in Mixed RankingOptimization
Personalized Re-rankingfor Recommendation
Seq2Slate:Re-ranking and Slate Optimization with RNNs
SlateQ: A TractableDecomposition for Reinforcement Learning with Slates
SoftSort: A ContinuousRelaxation for the argsort Operator
Differentiable Ranks andSorting using Optimal Transport
FromRankNet to LambdaRank to LambdaMART: An Overview

漂洗

2026-05-10T18:08:18.000Z

这是一个关于迁移的故事。

有一个人，从圣何塞搬到了西雅图。这两个城市差异并不小，圣何塞阳光很足，空气干燥，生活像一张等待填写的表格；西雅图则经常下雨，天色低下来，很多事情反而慢慢浮出水面。

起初，这像是一个关于工作、搬家、租房、洗衣、买菜和适应新语言的故事。后来才发现，它更像是一段重新学习生活的过程：学习如何安放自己的紧张、期待、欲望和好奇，也学习如何在任务、目标和时间表之外，重新看见一场雨、一片云、一次日落。

人总以为迁移意味着抵达另一个地方。后来才发现，真正被移动的，常常是自己看世界的方式。那些在阳光下匆忙学会的句子、路线和生活规则，后来都要被带进更长的雨里。

干燥的阳光

圣何塞的空气很干。

干到他每天早上醒来，喉咙里像含着一小块纸。酒店的窗户不能完全打开，窗外是停车场、几棵棕榈树和一条没有行人的路。阳光每天都很好，好得有点不讲道理，像一种温和但固执的提醒：既然已经来了，就先往前走。

他刚来美国的第六天，终于学会了使用洗衣房的机器。先扫码，再选温度，再选normalcycle。洗衣机转起来的时候，他站在旁边看了一会儿，觉得自己像一件刚被投入异国系统的衣服，正在被漂洗、甩干、重新分类。

这个比喻有点惨，他自己也知道。但被漂洗本来就不是一件舒服的事。旧的标签被慢慢洗掉，旧的褶皱被水撑开，人被放进一个新的容器里，不知道最后会变成什么样子，只能跟着水流转。

手机上显示北京时间晚上 11 点。母亲发来一条微信，问他吃得惯不惯。

他回：还行。

其实他那天晚上吃的是微波炉加热的米饭、Walmart买的鸡肉和一盒有点太甜的酸奶。他本来想多解释几句，后来又删掉了。因为很多事情解释起来很麻烦。比如美国的鸡肉为什么这么大，酸奶为什么这么甜，洗衣机为什么要用app，为什么一个人明明住在阳光很好的地方，还是会在某些瞬间觉得四周安静得过分。

但他并不讨厌这种安静。

它有时候让人失重，有时候也让人轻下来。没有熟人，没有固定路线，没有楼下熟悉的便利店和夜宵摊，也没有过去生活里那些自动运行的惯性。一个人被放到新的地方，最开始当然笨拙。但笨拙也是一种被漂洗的方式 —— 旧的自己被一点点洗掉，新的自己还不知道长什么样。

他刚从中国调到美国，也正站在一种很熟悉的人生刻度上。签证、入职、银行账户、SSN、电话卡、酒店、租房、信用卡、401k，每一件事都像一个新开的任务单，等着被理解、拆解、执行、关闭。

他擅长这个。

或者说，他以前以为自己主要擅长这个。

在国内的时候，他习惯把问题变成模型。收入、税率、房租、通勤、时间成本、健身计划、投资路径、职业选择，最好都能有一张表。每一列代表一个变量，每一行代表一个方案。最后排个序，选出性价比最高的那个。连人生本身，也像有一张默认的进度表：到了什么阶段该完成什么，慢一点都像落后。

换算一切

来到美国以后，他发现生活忽然变成了一个巨大的英文界面。每个按钮都认识一点，但又不完全确定。

他开始换算一切。

首先是货币。他仍然会把美元换算成人民币。一盒酸奶六刀，他会想四十多块。一次Uber三十刀，他会想两百多。餐厅随便吃一顿二十几刀，他会想这在国内可以吃什么。每次这样换算，他都感到不舒服，像是身体已经到了美国，消费心理还留在中国。

他知道这种比较没有意义。工资也变了，税也变了，生活系统也变了。可是知道没有意义，不代表不会自动发生。人脑不是一个随时能关闭的换算器。尤其是在刚到一个陌生地方的时候，所有价格都像在提醒他：你正在切换单位。

然后是语言。他开始积累一些小词，像在学习新的换算规则。Extra rinse是多漂洗一次，voicemail 不是短信，have a good day不是客套，而是日常润滑剂。最有用的一句是” Could you speak a littleslower?“—— 他在银行柜台说出这句话的那天，觉得自己终于有了一件趁手的工具。

刚来美国的人，往往不是在什么宏大的场景里感到自己进入异国，而是在一个很小的操作面前突然意识到：原来生活可以从这里重新开始。站在洗衣机前，不知道怎么开始；站在Chase 柜台前，不知道 banker 刚刚说的是哪一种fee；站在酒店前台，想说水池堵了，却在脑子里先把句子排练三遍。

后来他终于把那句英文说出口，事情也就用二十秒解决了。他回到房间，坐在床边，忽然觉得有点可笑：原来很多以为跨不过去的坎，真的跨过去时，只是一句完整的话。也是从这些二十秒里，他开始换算尴尬和紧张 —— 把它们换算成经验，换算成进度。

圣何塞的夏天白天很长。傍晚七点多，天还亮着。他第一次意识到，地球不是一个抽象的球体。它会通过天黑的时间、空气的湿度、太阳的角度，具体地改变一个人的身体感。北京的傍晚等于灰尘、饭馆、人声、楼道里的脚步，圣何塞的傍晚等于光、停车场、安静的马路、偶尔经过的车。他换算了好几次，汇率始终不对。

他不买车。

于是城市变得很奇怪。地图上看起来很近的地方，走起来却不像给人走的。人行道有时突然中断，商场和商场之间隔着巨大的停车场，超市就在一英里外，但路上没有几个行人。阳光很好，却没有烟火气。

他在没有车的城市里走路，走出了一种奇怪的清醒。

他开始怀念一些以前并不觉得美好的东西。比如楼下便利店，比如外卖骑手，比如小区门口的水果摊，比如晚高峰地铁里人的汗味和沉默。那些东西以前只是日常，离开以后才变成一种确定性。

不过，另一种感觉也慢慢出现。

他开始习惯一个人走路去附近的Costco，推着购物车在货架之间慢慢走。这对于刚到美国的他算一种奢侈，因为没有车，其实是很难去这种仓储式超市的，刚好他住的地方就在Costco 旁边，他想也许这也算一种新手福利。

刚开始他只是想买最便宜、最实用、最不会出错的东西。后来他会停下来看看不同口味的酸奶，看看冷冻柜里那些可以直接微波炉加热的晚餐，看看一袋袋奇怪但方便的vegetablekit。美国超市有一种粗糙的丰富，很多东西谈不上精致，却给人一种 “你可以先这样活下去” 的踏实。

最开始一个月，他住在酒店里，房间每天都被整理得差不多。床单白，灯光暖，微波炉在角落里，冰箱会发出轻微的声响。酒店的生活干净、方便、没有根。它不要求你承担太多，也不允许你真正留下什么。你可以把衣服挂进柜子，把牙刷放在洗手台，把电脑摆在桌上，但你知道，这不是家。你只是在这里暂时被安置。

这并不完全是坏事。

刚到一个地方，人有时也需要这种暂时性。像一艘船先停在码头，不急着立刻建房子。酒店替他处理掉很多生活摩擦，让他可以把精力用来学习那些更基础的事情：怎么开账户，怎么办电话卡，怎么报销，怎么跟前台沟通，怎么在英文里表达不满，又不显得失控。

有一天早上五点多，他被楼上的脚步声吵醒。声音很重，像有人在房间里反复搬动自己的生活。连续三天都是这样。他躺在床上，打开手机组织句子，写了又删，删了又写，最后还是没有打过去。不是因为不吵了，而是因为已经快到六点。他索性起床，冲了杯咖啡，去健身房。

健身房里没有几个人。跑步机、哑铃、镜子、电视屏幕，都有一种标准化的安静。他练胸，练肩，练背。刚来美国的那段时间，他很认真地健身，因为这是少数他还能完全理解的事情。

重量就是重量。
次数就是次数。
动作标准不标准，身体会立刻告诉你。
练完以后，心跳加快，肌肉充血，人会短暂地相信自己仍然掌控着什么。

这种掌控感不一定宏大，但很有用。身体像一个随身携带的小故乡。无论在哪里，只要你把哑铃举起来，再放下去，肌肉都会用同一种方式回应你。这是唯一不需要换算的东西。

回到房间，他打开电脑，开始处理工作消息。Lark上有人发来一串英文，他看得懂大部分，但仍然要花比以前更多的力气判断语气。对方是在催吗？是在客气吗？是在暗示他做得不够好吗？

他以前以为语言是工具。到了美国以后才知道，语言也是一种换算 —— 把一种文化里的潜台词，翻译成另一种文化里的行动。你站在里面，会慢慢学会冷暖变化。哪句话只是寒暄，哪句话是真的邀请，哪句话听起来轻描淡写，其实需要立刻处理。刚开始他常常紧绷，后来慢慢发现，大多数日常交流并没有那么可怕。别人问How are you doing? 并不是真的要他汇报人生状态。他说 Good, how about you?就已经足够。

他换算了一切：货币、时间、语言、距离、温度。有些换算越来越熟练，有些始终别扭。但他慢慢接受了一件事 —— 换算不一定都要成功，重要的是开始换算。

走进雨季

几周以后，他要搬去西雅图附近的 Bellevue。公司在那里，Lincoln Square附近。于是他开始看房。

Studio，1B1B，2B2B。
Downtown Bellevue，Redmond，Kirkland，Eastgate。
步行时间，骑车时间，公交时间，治安，超市，健身房，洗衣机，押金，leaseterm。

他又回到了自己熟悉的状态：比较，计算，排序。

可是租房不是一个单纯的数学问题。每一个选项后面都藏着一种生活。住得近，贵；住得远，省钱，但每天通勤会消耗人。房间大，舒服，但可能空旷；studio小，却容易打理。2B2B便宜一些，但室友意味着不确定性。安全、距离、空间、预算，没有一个能被完全满足。

他忽然想起以前看过的一句话：成年人的生活，不是在好和坏之间选择，而是在不同的代价之间选择。

他过去不太喜欢这种话，觉得太鸡汤。现在发现，它只是朴素。

搬去 Bellevue 那天，天气阴。

飞机降落前，他从窗户往下看，看见云层、湖、森林和一片灰绿色的城市。那种绿和加州不一样。圣何塞的绿是被阳光照得有点干的绿，西雅图的绿像一直浸在水里。

他到达的时候，下着小雨。

不是电影里那种适合告白或分别的大雨，而是一种没有明确边界的雨。你说它在下，它又好像只是空气比较湿；你说它没下，头发和外套又会慢慢变潮。人走在路上，不太确定自己需不需要撑伞。

Bellevue 很干净。

干净到不像一个传统意义上的城市。楼很新，玻璃很多，街道宽，车也规矩。LincolnSquare像一个巨大的、被擦亮的容器，里面装着办公室、餐厅、咖啡、商场、酒店、健身房，以及一些看起来永远不太狼狈的人。

他在这里上班，吃饭，买咖啡，看房，走路。雨经常在。他一开始觉得新鲜，后来觉得烦，再后来慢慢习惯。雨成了城市的一层滤镜。很多东西经过它以后，都显得慢一点，冷一点，也安静一点。

圣何塞让他觉得自己被放在明亮的日光下，必须尽快运转起来。 Bellevue让他觉得自己走进一段更长的叙事，节奏慢下来，很多没有想完的问题可以继续想。

在圣何塞，一个人难过会觉得自己不合时宜。外面阳光那么好，难过像一种不配合。可那种阳光也有好处，它会把人往外推，让人出门，让人行动，让人相信很多事情可以先做起来。

在西雅图，一个人难过会觉得世界至少没有反对。窗外也是灰的，树也是湿的，路灯也是模糊的。你的情绪不再需要解释，它只是混入了天气。但西雅图的雨也不只是伤感。它更像一种允许：允许人慢一点，允许人不那么急着给生活下结论，允许人在新的城市里重新安排自己。

他不是讨厌圣何塞，也不是立刻爱上西雅图。

他只是感觉到，两座城市像两种不同的性格。一个明亮、干燥、功能明确，让人学习生存；一个潮湿、安静、有一点迟疑，让人学习停顿。而他刚好需要这两件事。

先活下来，再慢慢想清楚怎么活。

在模糊里待着

他就是在这样的雨季里，开始注意到一个女生。

她是他在圣何塞时认识的同事，不是很熟。有共同认识的朋友有意撮合。他当时没想太多，后来搬到西雅图，两人仍然偶尔有些联系，他发现自己开始期待她的消息。

至于这算什么，他说不好。

他知道自己并不了解她。这种感觉，可能只是陌生生活里突然出现的一点光。人在新的地方，很容易把一个不那么熟的人想象得过于完整。她回消息慢，他会想是不是不感兴趣；她解释一句” 刚刚没看手机”，他又会想是不是在意他的感受。

信号是模糊的。所有关于她的判断，都像隔着一层雨雾。他看不清她的真实想法，也看不清自己的。

但他也没有急着离开这种模糊。

这种注意力的偏移，本来就不一定从充分了解开始。很多时候，它只是人群里更容易看到她，手机亮起时会多想一秒，听到别人提起她会下意识认真一点。理性当然应该提醒自己不要过度投射，但如果把所有心动都立刻归因成孤独、欲望或样本偏差，也未免太不近人情。

而作为一个习惯分析的人，他开始分析自己的分析。

回消息慢是否意味着冷淡？
解释” 刚刚没看手机” 是否是一种安抚？
自己喜欢的到底是她，还是” 被某个优秀女性看见” 的感觉？
这是不是太久没有亲密关系之后的投射？

问题越问越多，答案始终模糊。他甚至觉得，这个过程本身很有意思。

人可以把推荐系统、广告竞价、长期价值、策略优化讲得头头是道，一旦面对一个具体的人，就立刻变得像一个初学者。所有反馈都延迟，样本量永远不够，最重要的变量完全不可观测，还偏偏不能A / B test。

他曾经以为理性能保护自己，把模糊的东西变清晰。后来发现，理性有时候不是为了消灭模糊，而是为了学会在模糊里待着 —— 不急着判断，不急着否定，也不急着给答案。

他没有立刻做什么。只是偶尔聊天。聊工作，聊天气，聊搬家，聊附近哪里吃饭方便。有时候对方回得自然，他心情会变好；有时候隔很久不回，他就提醒自己不要过度解读。

人的心不是一个听话的下属。你给它写再清楚的策略，它也会在夜里悄悄运行另一套逻辑。

但他也慢慢学会不急着审判自己。这点心动也好，投射也好，欲望也好，好奇也好，它们并不总是互相排斥。一个人在新的地方，心里生出一些期待，本来就是正常的。那期待未必会通向某段关系，但它说明他还在对世界产生反应。

这比麻木要好。

他发完消息，把手机放到一边，去洗了个碗。他不知道这算不算喜欢，但他知道，喜欢一件事和把它想清楚，常常不是同一件事，也不需要同时发生。

还行

洗完碗，水声停下来，房间显得更空。

新租房常见的空。没有旧家具，没有熟悉的气味，没有被生活磨出来的痕迹。窗外还在下雨。他坐在地上，看了一会儿手机。国内已经是第二天。朋友圈里有人晒聚餐，有人加班，有人结婚，有人发小孩照片。那些生活没有因为他离开而暂停。

他突然想起刚来美国时母亲问他吃得惯不惯。

他当时回：还行。

其实这句话可以回答很多问题。

在美国生活怎么样？还行。
工作适应吗？还行。
一个人孤独吗？还行。
对那个女生的期待有结果吗？还行。
你现在快乐吗？还行。

“还行” 是一种很中国的保护色。它不撒谎，也不交代全部。但他后来慢慢发现，” 还行” 不一定只是敷衍。它也可以是一种过渡状态 —— 不是很好，也不是很坏；不是已经安顿，也不是完全漂着；不是兴奋到忽略困难，也不是悲观到看不见可能。它更像一句老实话：我还在路上，但我没有停下来。

他开始做饭。

淘米，放水，把速冻蔬菜倒进锅里，又煎了两个鸡蛋。美国的鸡蛋没有什么特别，米也普通，蔬菜甚至有点寡淡。但热气冒起来的时候，房间终于不像一个临时空间。食物有一种很低级也很可靠的力量：它不解决人生问题，但它让人暂时回到身体里。

那天晚上，他没有继续研究最新的算法，也没有查信用卡攻略，没有看投资组合，也没有打开健身计划。他只是坐在桌前，把饭吃完。

窗外雨声很轻。不是诗意的那种轻，而是生活本来的轻。它不负责安慰谁，只是一直落着。

他想，也许自己来到美国以后，一直在问同一种问题：

怎么做才最优？
怎么沟通才不出错？
怎么花钱才划算？
怎么训练才有效？
怎么投资才合理？
怎么租房才安全又便宜？
怎么判断一个人对自己的感觉？
怎么把人生的风险降到最低？

这些问题都很重要。它们让人活得更稳一点，更少犯错一点。可是问得太久以后，人会误以为生活本身也应该有一个最优解。

他以前也默认，人生该按某种节奏推进：什么时候站稳，什么时候拥有更多，什么时候不该再试错。可搬来这里以后，他才慢慢发现，很多真正重要的东西 —— 适应一个地方，长出新的日常，学会和自己相处 —— 都有自己的时间，不按那张表走。

而生活也不是一个 objective function。

它没有一个清晰的目标，也没有一组固定的约束。很多时候，你甚至不知道自己在优化什么。是钱，是自由，是安全感，是体面，是不孤独，还是某种 “我没有白来一趟” 的证明？

他曾经觉得，来美国是一个职业选择。后来发现，它不只是一次缓慢的自我拆解，也像一次迟来的重新发育。

很多在国内早已自动化的能力，在这里又重新长了一遍：买菜、说话、投诉、租房、做饭、判断一个人的语气，甚至判断自己到底想要什么。

在国内，他是熟悉系统里的人。知道怎么点外卖，怎么坐车，怎么表达不满，怎么开玩笑，怎么判断别人话里的意思。来到这里以后，他突然变成一个高收入的初学者。银行卡要学，洗衣机要学，医疗保险要学，电话套餐要学，连 “对方说have a good one 时该怎么回” 也要学。

这当然有点尴尬。

但也有一种奇怪的自由。一个人被迫重新学习日常的时候，也有机会重新选择日常。以前很多事情是默认的，现在每件事都要亲手建立：吃什么，住哪里，怎么花钱，怎么锻炼，周末去哪里，和谁保持联系，在哪些事情上节省，在哪些事情上对自己好一点。

原来生活不是由大选择组成的，而是由无数小动作维持的。能顺利买菜，能听懂前台，能把衣服烘干，能在雨里找到回家的路，能在夜里给自己做一顿饭，这些都不是理所当然。

他后来渐渐不再每天把美元换算成人民币。

不是因为东西变便宜了，而是因为他开始接受，自己正在进入另一个系统。换算当然还有用，但不能解释全部。六美元的酸奶不是四十多块人民币，它是某个晚上他懒得做饭时的一点方便；三十美元的Uber不是两百多块，它是雨夜里从机场回住处的一段安全感；两千多美元的房租不是一万多人民币，它是他在陌生城市里为自己买下的一小块稳定。

人不能一直用旧世界的单位衡量新生活。

也不能一直用过去的自己解释现在的情绪。

很多事情没有最优解，但还行。不是放弃，而是接受。

停顿

冬天真正来的时候，西雅图的天黑得很早。下午四点多，光就开始退。办公楼的窗户映着灰蓝色的天，湖面像一块沉默的金属。他下班后常常走一段路，再回住处。雨不大，风有点冷，路上行人不多。

他开始喜欢这种走路。不是为了健身，也不是为了省钱，只是为了让自己从工作里慢慢退出来，学会停顿。白天的他仍然要处理指标、实验、策略、会议、英文消息；夜晚的路上，他可以暂时不优化任何东西。

他也开始重新拍照。

其实他一直喜欢拍照。拍晚霞，拍日落，拍好看的云和山。拍得不算好，构图常常普通，曝光也不一定准确，但他还是喜欢。拍照这件事有一种很奇怪的诚实：你停下来，举起手机，对准某一片天空，按下快门。那一刻你没有优化什么，也没有证明什么，只是承认自己被眼前的东西打动了。

刚来美国的时候，他拍照少了很多。不是因为风景不好，而是因为心太忙，停不下来。人一旦进入解决问题的模式，世界就会退到背景里。天空只是天气，街道只是路线，超市只是补给点，房间只是临时住处，连夕阳也只是提醒你今天又快结束了。

后来有一天，他从 Lincoln Square下班出来，天边忽然出现一层很淡的金色。雨刚停，云还没有散开，远处的楼和树都被镶了一圈湿润的光。他原本只是想赶紧回去做饭，却在路口停了下来。

他抬起头，拿出手机，拍了一张。

照片当然没有眼睛看到的好。屏幕里的天空被压扁了，云的层次少了很多，路灯和车流也显得杂乱。但他看着那张照片，心情忽然轻了一点。不是因为拍得好，而是因为他发现，自己又学会了停顿 —— 有余力注意这些东西了。

他和那个女生后来没有发生什么戏剧性的故事。没有表白，没有拒绝，也没有电影里那种雨夜拥抱。他们仍然偶尔聊天，关系停在一个模糊但不夸张的位置。

他也没有特别失落。只是有一天发完消息、把手机放下去，他发现自己没有再拿起来看。

也许是因为那点好感消失了，也许是他慢慢明白，他想找的那个她，可以是一个真实的人，而不是他孤独的容器 —— 有自己的节奏、疲惫、忙碌和迟疑，而不是负责给他的异国生活提供意义。

有时候成长不是变得更勇敢，而是学会停顿 —— 少一点擅自加戏，多一点允许事情自己发生。不是把所有期待都压下去，而是允许期待存在，同时不让它替你写完整个故事。

还好

有一次开会，他一个人看着会议室白板上的流程图发呆。那张图他已经看了几十遍，每次都想着要优化哪个节点。那天他忽然意识到，自己已经有点记不清这张图最初要解决的是什么问题了 —— 只记得怎么让它跑得更快。他想，也许生活也一样：优化久了，人会忘记自己最开始想要的是什么。

可是很多东西不会因为着急就更快抵达。

签证有签证的时间。
信用分有信用分的时间。
语言有语言的时间。
肌肉生长有肌肉生长的时间。
喜欢一个人，也有喜欢一个人的时间。
一个人在异国真正安顿下来，更有它自己的时间。

他慢慢意识到，自己以前太相信那些外面给出的时间表了，好像晚一点就是迟，慢一点就是错。可真正的生活不是考勤。它只会在你一天天买菜、做饭、走路、开口、安静下来的时候，慢慢长出来。

那天晚上，他回到住处，给母亲发了一张自己做的晚饭照片。米饭，鸡蛋，蔬菜，还有一小碗汤。母亲回了一个大拇指，又问他冷不冷，衣服够不够。

他回：够的，最近经常下雨。

发完这句，他停了一下，又补了一句：

不过也还好，慢慢习惯了。

这一次，” 还好” 不再只是敷衍。

很多事情仍然不确定，工作、房子、感情、身份、未来都会继续摇晃。但他已经可以在摇晃里做饭、洗衣服、上班、走路、睡觉，偶尔也发呆。圣何塞的阳光让他学会行动，西雅图的雨让他学会停顿。至于两者之间的平衡，他还没有答案，但已经不急着立刻给出答案了。还好。

不撑伞

某个周末下午，雨停了一会儿。他从超市出来，手里提着一袋东西。天空还是灰的，但云层后面有一点很淡的光。街边的树湿着，车从路上开过，带起轻微的水声。

他停在路口等红灯。那一瞬间，他突然想起刚到圣何塞时，站在洗衣房里看机器旋转的自己。那时他不知道最后会被洗成什么样子。

现在还是不知道。但他已经不那么在乎了。

噪声、甩干、重新分类，这些过程当然不总是舒服，但也许人就是这样慢慢变得柔软一点，清楚一点。或者至少，洗掉了那些被硬塞进去的标签，露出了自己原来的颜色。

他走回住处。雨又开始下。

这一次，他没有撑伞。雨落在外套上，有点凉，有点湿。他提着东西，走进了雨里。

Uplift Modeling and Strategy Optimization in Practice

2026-05-02T23:51:23.000Z

Many business problems appear to be prediction tasks on the surface,but what they really need is intervention decision-making. For example,when sending coupons, buying ads, or adjusting traffic allocation, thereal question is usually not “who is most likely to convert?” but ratherwho should we intervene on to generate the largest netincremental lift?

This distinction between the two types of problems leads tofundamentally different modeling approaches.

Traditional predictive models are good at answering questions like“will this user buy?” or “will this user retain?” But they struggle toanswer questions like “if I send this coupon, will the user buy morebecause of it?” or “if I reduce live-stream exposure, will the user’slong-term value improve?” The former is a correlation problem; thelatter is a causality problem.

The value of Uplift Modeling lies in shifting the optimization targetfrom outcome prediction to estimating the incremental effect of anintervention. Compared with “finding high-probability users,” itfocuses more on “finding high-incrementality users,” so thatunder resource constraints we can maximize the true objective value of astrategy.

This article attempts to introduce the basic principles of uplift anda real-world application scenario. The main contents are as follows:

Why traditional predictive models are not suitable for directlyguiding intervention strategies
The causal inference foundations behind Uplift Modeling and commonmodeling methods
How to understand offline evaluation metrics such as AUUC andQini
In general business strategy optimization scenarios, how to go fromexperiment design all the way to online deployment
Modeling ideas for extended scenarios such as multiple treatmentsand continuous treatments

Problem Definition

Correlation ≠ Causation

“Correlation does not imply causation” is almost a cliché in dataanalysis, but in concrete business settings it is often the easiestthing to overlook. Consider a few classic examples.

Ice cream sales and drowning accidents

In the data, ice cream sales and drowning accidents are often highlypositively correlated. But clearly, banning ice cream would not reducedrownings. The real common cause is temperature: when the weather ishot, people are both more willing to eat ice cream and more willing togo swimming.

Years of education and income level

People with more years of education usually earn more, but this doesnot automatically mean that “studying for a few more years” willincrease everyone’s income in the same proportion. Factors such asability and family background may affect both educational choice andincome.

Users who receive coupons spend more

This kind of conclusion is extremely common in marketing scenarios.But the problem is that coupons may have already been targeted athigh-value users. In that case, the relationship between “receiving acoupon” and “high spending” may not be caused by the coupon at all; itmay simply reflect the correlation induced by the targetingstrategy.

Behind these examples lies the same core issue: what the businessreally needs is what changed because of theintervention, not merely that “the intervention and the outcomehappened together.”

Limitations ofTraditional Prediction

Traditional machine learning models usually take the outcome $Y$ as the prediction target:

\[\hat{Y} = f(X)\]

What they do well is: given user features $X$, predict whether the user willultimately take some action. This works for many tasks, but once thequestion becomes “should we intervene on this user,” three limitationsshow up.

(1) High-probability users are not the same ashigh-incrementality users

Suppose we want to optimize purchases after coupon distribution.Traditional models usually identify the people with the highest purchaseprobability, but these people may not actually be worth targeting.

User type	Without coupon	After coupon	Worth intervening on?
Sure buyers	Will buy	Will buy	No
Persuadables	Won’t buy	Will buy	Yes
Lost causes	Won’t buy	Won’t buy	No
Sleeping dogs	Will buy	Won’t buy	Should avoid

Traditional models can only identify “who is more likely to buy,” butthey cannot distinguish whether those people are sure buyers,persuadables, or sleeping dogs. Yet in practice, the people worthallocating resources to are usually only the second group: thosewhose behavior changes positively because of theintervention.

(2) They cannot identify the direction ofcausality

In advertising, if we observe that “users who saw the ad convertedmore,” this does not prove that the ad improved conversion. It maysimply be that users who were already easier to convert were also easierto target with ads, or more likely to be allocated ad exposure by thesystem.

(3) They cannot see the counterfactual

When making decisions, what we really care about is:

What happens after intervention
What happens without intervention
How large the difference is

But traditional predictive models usually only observe the one worldthat actually happened, and cannot see “what would have happened if wehad not done it.”

And that counterfactual is exactly the key object in causalestimation.

What Uplift Is Estimating

Uplift Modeling does not focus on the outcome itself, but on the netchange caused by an intervention.

For a single user $i$, what wewant to estimate is:

\[\tau_i = Y_i(1) - Y_i(0)\]

where:

$Y_i(1)$ is the outcome if theuser receives the treatment
$Y_i(0)$ is the outcome if theuser does not receive the treatment
$\tau_i$ is the incrementaleffect of the treatment on that user

This makes the difference between traditional prediction and UpliftModeling very clear:

Dimension	Traditional predictive model	Uplift Modeling
Core question	Will the user convert?	Can intervention make the user convert more?
Learning target	Outcome probability	Causal incrementality
Identification target	High-probability users	High-incrementality users
Strategic consequence	May waste resources	Better suited for fine-grained targeting

Theoretical Foundations

Potential Outcomes

From a theoretical perspective, the most common foundation for UpliftModeling is the Potential Outcomes Framework in causal inference.

For any user $i$, there aretheoretically two potential outcomes:

$Y_i(1)$: the outcome afterreceiving the treatment
$Y_i(0)$: the outcome withoutreceiving the treatment

The Individual Treatment Effect (ITE) is defined as:

\[\tau_i = Y_i(1) - Y_i(0)\]

But this immediately runs into a classic difficulty: for thesame user, we can never simultaneously observe the states “treated” and“untreated.” This is the Fundamental Problem of CausalInference.

Therefore, in practice we usually do not directly estimate the trueITE for an individual user. Instead, we estimate the Conditional AverageTreatment Effect (CATE):

\[\tau(x) = E[Y(1) - Y(0) \mid X = x]\]

That is: among people with similar features, how much change doesthe intervention create on average? This is what most uplift modelsactually try to learn.

Four Types of Users

From a business perspective, one of the biggest values of uplift isthat it lets us move from “segmenting users by outcomes” to “segmentingusers by treatment response.” A common four-quadrant breakdown is asfollows:

User type	Behavior after treatment	Behavior without treatment	Treatment effect	Strategy recommendation
Persuadables	Positive	Negative	Positive	Worth treating
Sure Things	Positive	Positive	Close to 0	No need to treat
Lost Causes	Negative	Negative	Close to 0	No need to treat
Sleeping Dogs	Negative	Positive	Negative	Avoid treatment

The most important group here is Persuadables; the oneto avoid most carefully is Sleeping Dogs.

Many business strategies look like “users with higher model scoresget more aggressive exposure,” but if high-score users are mostlySure Things, resources are wasted. And if we accidentallyharm a large number of Sleeping Dogs, the strategy may evencreate negative returns.

Three Assumptions

To make uplift estimation credible, we usually rely on at least thefollowing three assumptions.

1. Unconfoundedness

\[(Y(1), Y(0)) \perp T \mid X\]

That is, conditional on features $X$, treatment assignment $T$ is independent of the potentialoutcomes.

In plain language: if the treatment is targeted by an onlinestrategy, and that strategy is itself strongly correlated withconversion tendency, then confounding is easily introduced. In thatcase, we can no longer tell whether “the treatment worked” or whether“the treated people were already more likely to convert.”

So in uplift settings, we usually rely on RCTs to make treatmentassignment as random as possible, thereby reducing confounding andimproving identifiability.

2. Overlap

\[0 < P(T=1 \mid X=x) < 1\]

This means that for any type of user, there should be some chance ofentering either the treatment group or the control group. Everysubgroup must contain both treatment and control samples,otherwise the model cannot learn the before-vs-after treatmentdifference for similar users, i.e., the CATE.

3. Stable Unit Treatment Value Assumption

A user’s potential outcome should be affected only by that user’s owntreatment status, and not by the treatment statuses of other users.

In simple terms, the treatment effect of a user should depend only onthat user’s own treatment.

But if other people’s treatments can also affect that user, theproblem becomes more complicated. The outcome no longer depends only on“was I treated,” but also on factors like whether my friends weretreated, whether other merchants received subsidies, or whether otherusers in the same traffic pool were treated.

In real business settings, this assumption may be violated whenthere are strong social spillovers, resource competition, orsystem-level interactions between users.

For example, suppose we study whether a person getting vaccinatedreduces that person’s infection risk. If only “did this person getvaccinated” matters, the comparison is simple. But in reality, whetherother people are vaccinated also affects you: if many people around youare vaccinated, virus transmission weakens overall, so even if you arenot vaccinated, your infection risk drops. That is a case where SUTVAdoes not hold.

In practice, SUTVA often does not hold perfectly in real businesseseither. Many businesses naturally involve interactions: socialcontagion, resource competition, inventory constraints, and so on. Forexample, in LT optimization, suppressing one content genre may increasethe user’s consumption of other genres, so the user’s final LT change isjointly affected by both genre shifts.

So SUTVA is often not a binary “fully true” or “fully false”assumption. Rather, the question is: how strong is theinterference, and can it be ignored?

If the interference is weak, engineering practice may accept it as anapproximation. If the interference is strong, the experiment may need tobe redesigned, for example:
- randomize by group rather than by individual, e.g. send coupons to thesame friend circle together instead of splitting them
- switch from “user-level randomization” to “time-level randomization,”i.e. do not let some users be treated and others untreated at the sametime; instead, turn treatment fully on in some time windows and fullyoff in others

Modeling Methods

There is no single standard answer in Uplift Modeling. In engineeringpractice, two families of methods are more common:

Meta-Learners: decompose causal effect estimation into severalsupervised learning subproblems, such as various xx-Learners
Direct Uplift Models: directly design the model or splittingcriterion around the treatment effect; Causal Forest is the most commonrepresentative of this family

Below is a brief introduction.

Meta-Learners

1. S-Learner

The idea of the S-Learner is the most direct: treat the interventionvariable $T$ as a standard feature,and feed it into the model together with the other user features.

\[\mu(x, t) = E[Y \mid X=x, T=t]\]

At serving time, for the same user we input $t=1$ and $t=0$ separately, and the differencebetween the two predictions is the uplift estimate:

\[\hat{\tau}(x) = \hat{\mu}(x, 1) - \hat{\mu}(x, 0)\]

Pros:

Simple to implement
All samples are used to train one model
A good baseline for quick validation

Cons:

If the treatment signal is weak, the model may ignore $T$
Regularization bias can appear under strong regularization

If you just want to quickly test whether uplift has potential in thebusiness, the S-Learner is often a very practical starting point. But ifyou truly care about higher-quality CATE estimation, it is usually notthe final answer.

2. T-Learner

The T-Learner fully separates the treatment group and the controlgroup, training two models independently:

\[\mu_1(x) = E[Y \mid X=x, T=1]\]

\[\mu_0(x) = E[Y \mid X=x, T=0]\]

Their difference is the uplift:

\[\hat{\tau}(x) = \hat{\mu}_1(x) - \hat{\mu}_0(x)\]

Pros:

Can fit different patterns for treatment and control separately
Less likely than S-Learner to wash out the treatment signal

Cons:

Each model only uses part of the samples, so sample efficiency islower
Performance degrades easily under sample imbalance
Errors from the two models accumulate

3. X-Learner

The X-Learner can be understood as improving sample efficiency on topof the T-Learner, especially in scenarios where treatment and controlsamples are imbalanced.

Its core steps can be summarized in three stages:

3.1 Train two response models

\[\hat{\mu}_1(x) = E[Y \mid X=x, T=1]\]

\[\hat{\mu}_0(x) = E[Y \mid X=x, T=0]\]

3.2 Construct pseudo causal effects

For treatment-group samples:

\[D_i^1 = Y_i^1 - \hat{\mu}_0(X_i)\]

For control-group samples:

\[D_i^0 = \hat{\mu}_1(X_i) - Y_i^0\]

Then train two separate effect models:

\[\hat{\tau}_1(x) = E[D^1 \mid X=x]\]

\[\hat{\tau}_0(x) = E[D^0 \mid X=x]\]

3.3 Combine them using propensity-scoreweighting

\[\hat{\tau}(x) = g(x) \cdot \hat{\tau}_0(x) + (1-g(x)) \cdot\hat{\tau}_1(x)\]

where $g(x)$ is usually taken asthe propensity score $P(T=1 \midX=x)$.

Pros:

More robust to sample imbalance
Often achieves better CATE accuracy than S-Learner andT-Learner
Better suited to asymmetric experiment designs in businesssettings

Cons:

More complex to implement and tune
Longer training pipeline and harder diagnosis

Direct Uplift Models

Direct Uplift Models refer to models that directly design the splitcriterion or loss function around the treatment effect. Common methodsinclude:

Uplift Tree: a tree adapted for uplift settings,using criteria such as KL / Euclidean / Chi-square distance to split,with the goal of maximizing the distribution difference betweentreatment and control groups
Causal Forest: an ensemble version of Causal Trees,with more statistically principled split criteria (e.g. CMSE, SFT),often combined with honest estimation

Their essential difference from ordinary decision trees is:

Ordinary trees: the split objective is about prediction error orclass purity
Trees in uplift: the split objective is about heterogeneity in thetreatment effect

Let us go through them separately.

1. What an ordinary decision tree does whensplitting

The splitting logic of an ordinary decision tree (classification orregression) is essentially trying to make each node more “pure.” Commoncriteria include:

Gini impurity

\[G = \sum_{k=1}^{K} p_k (1 - p_k)\]

where $p_k$ is the fraction ofsamples in the node that belong to class $k$. Smaller Gini means the node is morehomogeneous.

Information gain (based on entropy)

\[H = -\sum_{k=1}^{K} p_k \log p_k\]

The greater the entropy reduction after a split, the more the splitseparates the classes.

Mean squared error (MSE) for regression trees

\[MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \bar{y})^2\]

The splitting objective is to make the variance within the left andright child nodes as small as possible, so the predictions are moreconcentrated.

These criteria all reveal one thing: ordinary decision treesonly care about putting people with similar outcomes together.They do not care about the treatment, and they do not care about thedifference between “treated” and “untreated.” So using an ordinarytree to predict “will the user buy after receiving a coupon” is reallylearning “who is more likely to buy,” not “who becomes more likely tobuy because of the coupon.”

2. What an Uplift Tree does when splitting

An Uplift Tree no longer splits around “outcome purity,” but aroundthe difference between the treatment group and the controlgroup.

Its intuition is: if a split makes the treatment effect on theleft and right branches clearly different, then that feature is likelycapturing who is more sensitive to the intervention.

Common split criteria include:

KL divergence

\[D_{KL}(P^T || P^C) = \sum_y P^T(y) \log \frac{P^T(y)}{P^C(y)}\]

Euclidean distance

\[D_E = \sum_y (P^T(y) - P^C(y))^2\]

Chi-square distance

\[D_{\chi^2} = \sum_y \frac{(P^T(y) - P^C(y))^2}{P^C(y)}\]

These three formulas look different, but their core logic is thesame:

$P^T(y)$ is the outcomedistribution for the treatment group within the currentcandidate node
$P^C(y)$ is the outcomedistribution for the control group within the current candidatenode
The split objective is to make these two distributions asdifferent as possible

These are not global distributions, but empirical distributionsinside the node. For a binary purchase outcome, for example:

$P^T(1)$ is the fraction oftreated users in the current node who purchase
$P^T(0)$ is the fraction oftreated users in the current node who do not purchase
$P^C(1)$ is the fraction ofcontrol users in the current node who purchase
$P^C(0)$ is the fraction ofcontrol users in the current node who do not purchase

Why can a distribution difference reflectuplift?

There is an important mathematical link behind this. Forbinary-outcome problems (e.g. whether the user purchases), uplift isdefined as:

\[\hat{\tau} = P^T(Y=1) - P^C(Y=1)\]

That is, uplift is essentially the difference between the twodistributions at the point $Y=1$.

Consider an example that can be plugged directly into the formulas.Suppose the current node contains 200 users:

100 users in treatment: 30 purchase and 70 do not
100 users in control: 10 purchase and 90 do not

Then:

\[P^T(1)=0.3, \quad P^T(0)=0.7\]

\[P^C(1)=0.1, \quad P^C(0)=0.9\]

So the uplift of this node is:

\[\hat{\tau} = P^T(1) - P^C(1) = 0.3 - 0.1 = 0.2\]

In other words, within this node, the treatment raises purchaseprobability by 20 percentage points.

So what is the relationship between KL / Euclidean / Chi-squaredistance and uplift? Take Euclidean distance as an example:

\[D_E = \sum_y (P^T(y) - P^C(y))^2 = (P^T(1) - P^C(1))^2 + (P^T(0) -P^C(0))^2\]

Plugging in the numbers above gives:

\[D_E = (0.3 - 0.1)^2 + (0.7 - 0.9)^2 = 0.2^2 + (-0.2)^2 = 0.08\]

Because $P(1) + P(0) = 1$, we have$P^T(1) - P^C(1) = -(P^T(0) -P^C(0))$, so:

\[D_E = 2 \times (P^T(1) - P^C(1))^2 = 2 \times \hat{\tau}^2\]

In this example we can also see directly that:

\[D_E = 2 \times 0.2^2 = 0.08\]

Therefore, maximizing Euclidean distance is equivalent tomaximizing the square of uplift.

KL divergence and Chi-square distance can be understood as “weightedamplifications” of uplift. They not only consider the size of thedifference, but also the relative position of the distributions. When$P^C$ is close to 0 or 1, the sameuplift receives a larger weight.

So the shared logic of these three distances is: when $P^T$ and $P^C$ differ greatly, the treatment has astronger impact on the outcome, meaning the absolute uplift islarger.

But note that this is still about the difference within asingle node, not yet about whether a candidate split is good.When choosing a split, we do not compare whether the left node or theright node has a larger uplift by itself. What we compare is:how much the weighted score of the two child nodes improvesrelative to the parent node after the split.

In the binary-outcome + Euclidean-distance setting, the node scorecan be written as:

\[\phi(node)=D_E(node)=2\hat{\tau}_{node}^2\]

If a candidate split divides the parent node into left and rightchild nodes, its split gain can be written as:

\[\text{Gain}(s)=\frac{n_L}{n}\phi(L)+\frac{n_R}{n}\phi(R)-\phi(P)\]

Substituting $\phi(node)=2\hat{\tau}_{node}^2$ into itgives:

\[\text{Gain}(s) \propto \frac{n_L n_R}{n^2}(\hat{\tau}_L-\hat{\tau}_R)^2\]

This shows that, in this setting, what is really being maximized isnot the uplift of a single node, but the square of the uplift differencebetween the left and right child nodes.

So, more precisely, the question an Uplift Tree asks at each splitis: can this split separate users for whom the treatment isespecially useful from users for whom the treatment is barely useful, sothat the treatment effects of the two child nodes become as different aspossible?

Let us illustrate with an example. Suppose two candidate splitsproduce child nodes of similar size, and we want to decide which featureis better.

After splitting on candidate feature A:

Group	Purchase rate with coupon	Purchase rate without coupon	Uplift
Left	30%	10%	+20%
Right	25%	20%	+5%

After splitting on candidate feature B:

Group	Purchase rate with coupon	Purchase rate without coupon	Uplift
Left	28%	18%	+10%
Right	27%	17%	+10%

Feature A creates a 15% uplift gap between left and right (20% - 5%),while feature B produces almost the same uplift on both sides (both10%). If the child-node sample sizes are similar, then split gain isapproximately proportional to $(\hat{\tau}_L-\hat{\tau}_R)^2$.Therefore:

Feature A has a larger split gain, because it trulyseparates users into a “coupon-sensitive” group and a “lesscoupon-sensitive” group
Feature B has positive uplift in both child nodes,but the two sides are almost the same, so it does not really cut outheterogeneity

So the Uplift Tree will prefer feature A. What itprefers is not “make the uplift of a node as large as possible,” butrather “after the split, make the uplift of the left and right childnodes as different as possible.”

If we used an ordinary decision tree instead, the treatmentinformation would be mixed directly into the overall purchase rate. Inthat case, even if a split clearly enlarges the uplift gap, the tree maystill fail to recognize it. For the two splits above, if we only look atoverall purchase rate:

Purchase rate on A-left: (30% + 10%) / 2 = 20%
Purchase rate on A-right: (25% + 20%) / 2 = 22.5%
Purchase rate on B-left: (28% + 18%) / 2 = 23%
Purchase rate on B-right: (27% + 17%) / 2 = 22%

These overall purchase rates only answer “who is more likely to buy,”but they cannot directly answer “who is more likely to change because ofthe coupon.”

In one sentence: an ordinary tree makes the outcome withineach node purer (who is more likely to buy), while an Uplift Tree makesthe treatment effects of the left and right child nodes more different(who is more likely to be changed).

3. What a Causal Forest does when splitting

A Causal Forest can be understood as an ensemble version of a CausalTree, and it is one of the more commonly used methods in realbusinesses. Its core idea is not simply to “assign a score to eachuser,” but rather: for a target user $x$, automatically find a neighborhood ofsamples that are more similar to that user in treatment effect, and thenestimate the local CATE within that neighborhood.

Theoretical background: CMSE and SFT

The discussion above about KL / Euclidean / Chi-square is mainlyabout the Uplift Tree family: it evaluates nodes andsplits from the perspective of how much the outcome distributions oftreatment and control differ.

But along another, more statistics-oriented line of work—namelyCausal Tree / Causal Forest—researchers care more abouta different question: how can we make the estimate of thetreatment effect more accurate, while also ensuring that the differencewe see is stable and trustworthy? This leads to two theoreticallenses: CMSE and SFT.

CMSE (Causal Mean Squared Error)

In theory, we want to minimize the error of the causal effectestimate:

\[\text{CMSE} = E\left[(\tau(X) - \hat{\tau}(X))^2\right]\]

where $\tau(X)$ is the true CATEand $\hat{\tau}(X)$ is the modelestimate.

But the problem is: the true $\tau$ is unobservable, so CMSEcannot be computed directly. It is better understood as a theoreticalobjective: it tells us what we would ideally like to optimize, whilepractical algorithms must approximate it with a computable proxy.

A common approximation idea is this: if a split makes the truetreatment effects of the left and right child nodes clearly different,then the treatment effects within each leaf tend to become morehomogeneous. The more homogeneous a leaf is, the smaller the error tendsto be when we use a single $\hat{\tau}$ to represent all samples inthat leaf.

In other words, the intuition behind CMSE is not “compute the errordirectly,” but rather:

put people with different treatment effects into differentleaves, so that each leaf becomes more homogeneousinternally.

This can be understood through a familiar variance decomposition:

\[\text{Total variance} = \text{Between-leaf variance} + \text{Within-leafvariance}\]

If total variance is fixed, then a split that enlarges between-leafdifferences will usually reduce within-leaf differences. Smallerwithin-leaf differences mean the true $\tau$ values inside each leaf are moreconsistent, which is more favorable for reducing estimation error.

Of course, we have to be careful here: this logic is atheoretical motivation and approximation intuition, nota claim that every split criterion is strictly equivalent to CMSE. Oncewe move to an actual algorithm, we still need to choose a concrete,computable split objective.

SFT (Signal-to-Noise Ratio / stabilityconsideration)

Seeing a large effect gap between the left and right child nodes isstill not enough, because that gap may simply be noise. So anothernatural question arises:

is this difference a real heterogeneity signal, or just anillusion caused by small-sample fluctuation?

That is what the SFT / signal-to-noise perspective tries to answer:it is not enough to ask whether the difference is large; we also need toask whether it is stable.

If a split gives left uplift = 30% and right uplift = 5%, but theleft side contains only 10 samples, that difference may not be reliableat all. If both sides have sufficient samples and the gap reproducesstably, then it is much more likely to reflect real heterogeneity.

So CMSE emphasizes that estimation error should besmall, while SFT emphasizes that the difference shouldbe stable and trustworthy. Together, they point to the samegoal: find splits that exhibit heterogeneity and can also beestimated stably.

From a unified goal to two families of splitcriteria

At this point we can unify the earlier discussion: whether we aretalking about Uplift Trees or Causal Trees / Causal Forests, the coretask is the same—find splits with the largest treatment-effectheterogeneity. The difference lies in how they score thequality of a split.

1. Uplift Tree: starting from distributiondifference

A common Uplift Tree approach is to first measure theoutcome-distribution difference between treatment and control inside anode, using criteria such as KL / Euclidean / Chi-square distance.

In the binary-outcome setting, if Euclidean distance is used as thenode score, then:

\[\phi(node)=D_E(node)=2\hat{\tau}_{node}^2\]

Writing this as a split gain gives:

\[\text{Gain}(s)=\frac{n_L}{n}\phi(L)+\frac{n_R}{n}\phi(R)-\phi(P)\]

which implies:

\[\text{Gain}(s) \propto \frac{n_L n_R}{n^2}(\hat{\tau}_L-\hat{\tau}_R)^2\]

So in the binary-outcome + Euclidean-distance setting, an Uplift Treemay look like it is scoring “distribution difference inside nodes,” butwhat it ultimately prefers is still a split that creates a largetreatment-effect difference between the left and right childnodes.

2. Causal Tree / Causal Forest: starting from effectdifference and estimation error

Causal Tree / Causal Forest is more direct. Instead of going throughdistribution distance first, it usually constructs split criteriadirectly around the point estimate $\hat{\tau}$ of the treatment effect andits stability.

The most direct criterion is to choose the split that maximizes thetreatment-effect difference between the left and right child nodes:

\[\max_{j,s} \left( \hat{\tau}^{left}(j,s) - \hat{\tau}^{right}(j,s)\right)^2\]

Within a node:

the average outcome of the treatment group is $\bar{Y}^T$
the average outcome of the control group is $\bar{Y}^C$
the estimated treatment effect is $\hat{\tau} = \bar{Y}^T - \bar{Y}^C$

The intuition is straightforward: if a split makes the uplift on thetwo sides clearly different (for example, 15% on the left and -5% on theright), then the split has captured heterogeneity.

On top of that, we can also incorporate stability directly into thecriterion by using a t-statistic-style form:

\[\frac{\left(\hat{\tau}^{left} -\hat{\tau}^{right}\right)^2}{\widehat{Var}(\hat{\tau}^{left}) +\widehat{Var}(\hat{\tau}^{right})}\]

Here the numerator is the squared effect difference, and thedenominator is the sum of estimation variances. What it asks is:

if the uplift gap between left and right is this large, is itbecause there is real heterogeneity, or just because the sample is toosmall and the noise is too high?

This variance-adjusted type of criterion corresponds exactly to theSFT / stability perspective described above.

Key trick: Honest Estimation

No matter which $\hat{\tau}$-basedsplit criterion we use, one common issue remains: the split uses theestimate $\hat{\tau}$, not the true$\tau$. If the same data are usedboth to search for the split and to estimate leaf effects, the modelwill naturally prefer splits that happen to look very different in thisparticular sample.

That is why Causal Tree / Causal Forest is usually paired withHonest Estimation:

Sample	Purpose
Sample A	Decide how to split (discover heterogeneity structure)
Sample B	Estimate the treatment effect after splitting

By separating splitting from estimation, Sample B becomes the “fair”estimator of leaf effects, which can significantly reduce overfittingbias. More rigorously, this is also an important foundation for laterasymptotic normality and confidence-interval inference.

What exactly is the relationship between Uplift Tree andCausal Tree / Forest?

Now we can place the previous sections into one picture:

Shared goal: both are looking for splits with thelargest treatment-effect heterogeneity
Uplift Tree perspective: start from the differencebetween treatment and control outcome distributions
Causal Tree / Forest perspective: start from thepoint estimate of treatment effect and its estimation error

They are not literally the same split criterion. Rather, they are twomethodological routes serving the same goal.

Their connection becomes especially clear in the binary-outcomecase:

\[P^T(1) - P^C(1) = \hat{\tau}\]

So in the binary-outcome setting, “distribution difference” and“uplift difference” are essentially measuring the same thing; the maindifference is that the former emphasizes the full outcomedistribution, while the latter emphasizes the pointestimate of treatment effect and its stability.

Which method should you choose? It depends on business needs:

Need to consider changes in the full outcome distribution → thedistance measure in Uplift Trees is more comprehensive
Need a clean uplift point estimate and confidence interval → CausalTree / Forest is more direct
Sample size is limited and stability matters → variance-adjustedCausal Tree / Forest criteria are more robust

4. Summary: comparing the split objectives of three types oftrees

Method	Split objective	Plain-language summary
Ordinary decision tree	Minimize prediction error or class impurity	Put people with similar outcomes together
Uplift Tree	Maximize the distribution difference between treatment andcontrol	Distinguish people with different treatment effects
Causal Tree / Forest	Maximize treatment-effect heterogeneity while controlling estimationerror	Put people with different treatment effects together, and make surethe difference is trustworthy

More intuitively: ordinary trees learn “who is similar,”Uplift Trees learn “who is more likely to be changed,” and Causal Trees/ Forests learn “who is more likely to be changed, and this judgment isstatistically more defensible.” In uplift scenarios, CausalForest is generally used more often than Uplift Tree, although both havetheir own appropriate use cases.

The strengths of Causal Forest are:

Stronger engineering stability: a single UpliftTree is prone to overfitting and instability, while Causal Forest is anensemble method with better generalization
More complete theoretical support: honestestimation supports confidence intervals, and asymptotic normalitysupports statistical inference
Better at capturing complex heterogeneity: ithandles feature interactions and nonlinear relationships better, so itis more suitable for businesses with many features and complexrelationships

The strengths of Uplift Tree are:

Better rule interpretability: a single tree canoutput clear split rules, which makes it easier for operations teams tounderstand and execute; suitable for audience-segmentation insights
Fast prototyping: simple to implement and train,useful for quickly checking whether an uplift signal exists
Rule-engine deployment: some business systemsrequire explicit if-else rules, which Uplift Trees can directlyprovide

Common choices in real engineering practice:

Stage	Common method	Why
Quickly validate whether uplift exists	S-Learner / Uplift Tree	Simple and fast
Pursue higher CATE accuracy	X-Learner / Causal Forest	More robust and theoretically stronger
Need interpretable rule output	Uplift Tree	Better interpretability
Production deployment	Causal Forest / Meta-Learner	Stability comes first

In one sentence: Causal Forest is better suited to be the“main model” because it is stable, theoretically well grounded,and widely validated in industry; Uplift Tree is better suitedas an “auxiliary tool” for rule insight, audience segmentation,and fast prototyping.

Method Selection

If we compare the methods discussed above together, the picture looksroughly like this:

Method	Suitable scenario	Pros	Cons
S-Learner	Quick validation, small data	Simple to implement, high sample efficiency	Easily fails when the treatment signal is weak
T-Learner	Balanced samples, clear effect	Intuitive structure	Low sample efficiency, error accumulation
X-Learner	Sample imbalance, higher precision	More robust, usually better performance	More complex pipeline
Uplift Tree	Need rule explanations, user segmentation	Good interpretability	Moderate stability
Causal Forest	Strong nonlinearity, need more stable estimates	Stronger theory, can capture complex effects	Higher computational cost

There is no silver bullet in engineering. In many cases, the bestapproach is not to pursue the most complex model from the start, butrather:

Use a simple baseline to quickly verify whether uplift reallyexists
Then gradually move to a stronger effect learner
Finally, focus on how the strategy is used, rather than only staringat offline scores

Evaluation Metrics

Uplift evaluation differs from ordinary classification or regression.The reason is simple: the true ITE is unobservable—we never get to seewhat the same user would have done in both the treated and untreatedworlds.

Uplift models are therefore usually evaluated along twodimensions:

Ranking: whether the model places users with largertreatment effects—and thus greater value from intervention—near thetop
Calibration: whether predicted uplift values agreewith the group-level treatment effects estimated in the correspondingpopulations

AUUC and Qini mainly evaluate ranking. They share some intuition withAUC in classification, but they are not the same mathematical object.Evaluation must also use an independent test set or out-of-foldpredictions; otherwise, rankings measured on the training set will beoverly optimistic.

One caveat is that the terms “uplift curve,” “gain curve,” and “AUUC”are not used consistently across papers and libraries. To avoid mixingareas computed from different y-axes, this article uses the followingconvention:

$U(p)$: the averageuplift among the top $p$fraction of users
$G(p)=pU(p)$: thecumulative gain, normalized by the full population
AUUC: the signed area under the cumulative gaincurve $G(p)$
Qini coefficient: the signed area between thecumulative gain curve and the random baseline $p\cdot ATE$

Some libraries further divide by the area under a perfect-rankingcurve. Before comparing reported values, always confirm the y-axis, therandom baseline, and whether the metric has been normalized.

Average Uplift Curve

Imagine 1,000 users sorted from highest to lowest by predicteduplift:

First take the top 10% from an independent RCT test set. If thisprefix contains enough treatment and control samples, estimate itsaverage uplift as the difference between the two groups’ outcomemeans.
Then expand the prefix to the top 20%, 30%, and so on, re-estimatingthe average uplift at each coverage level.
Continue until the prefix covers the entire population.

For the top $k$ samples in theranking, the average uplift estimator is:

\[\hat U(p_k)=\frac{1}{N_k^T}\sum_{i\leq k,\,T_i=1}Y_i-\frac{1}{N_k^C}\sum_{i\leq k,\,T_i=0}Y_i,\qquad p_k=\frac{k}{N}\]

Here, $T_i\in\{0,1\}$ is thetreatment assignment, $Y_i$ is theobserved outcome, and $N_k^T$ and$N_k^C$ are the numbers of treatmentand control samples in the prefix.

This estimator requires both groups to be present: $N_k^T>0$ and $N_k^C>0$. Randomization makes thegroups comparable in expectation over repeated samples; it does notguarantee adequate empirical overlap in every finite prefix. If a prefixis too small, expand it, combine adjacent bins, or omit that coveragepoint.

Conceptually, this process estimates the uplift we would expect ifthe policy treated only the selected prefix. Plotting “coverage $p$ → average uplift in the prefix” givesthe average uplift curve $U(p)$. Ifthe ranking is effective, the beginning of the curve will usually lieabove the population ATE. At full coverage, the population curvesatisfies:

\[U(1)=ATE\]

Under random ranking, each prefix has the same expected populationcomposition as the full sample, so:

\[\mathbb E[U_{\mathrm{rand}}(p)]=ATE\]

The random baseline for the average uplift curve is therefore ahorizontal line at the ATE. An effective ranking usually places thebeginning of the model curve above this baseline.

When the model ranks users accurately, high-uplift users come first,so the average uplift curve often slopes downward from the upper left. Afinite-sample curve is noisy, however, and need not be monotone.Monotonicity is guaranteed only at the population level when the rankingagrees perfectly with the true CATE.

A common question is whether the top $k$ users must be homogeneous.

If two users are called homogeneous only when all features used bythe model are identical, this condition can be written as $X_i=X_j$. It is directly related to thedefinition of CATE:

\[\tau(x)=E[Y(1)-Y(0)\mid X=x]\]

AUUC evaluation does not estimate the CATE at one fixed value of$x$. It estimates the group-leveltreatment effect of the entire prefix selected by the model. Define thetop $p$ fraction as:

\[S_p=\mathbb{1}\{s(X_{\mathrm{pre}})\geq c_p\}\]

Then the corresponding point on the average uplift curve is:

\[\begin{aligned}U(p)&=E[Y(1)-Y(0)\mid S_p=1] \\&=E[\tau(X)\mid S_p=1]\end{aligned}\]

This quantity is also the Group Average Treatment Effect (GATE) ofthe prefix. A prefix may contain many values of $X$ and many different CATEs; $U(p)$ averages those effects according tothe composition of the selected population. If the onlinepolicy will treat the whole prefix, the quantity has a direct businessinterpretation: $U(p)$ is theexpected increment per treated user, while $N\cdot p\cdot U(p)$ is the expected totalincrement from treating the top $p$fraction among $N$ candidateusers.

For example, suppose a prefix contains 60% type-A users with a CATEof 20% and 40% type-B users with a CATE of 5%. The users are nothomogeneous, but if the policy treats both types, its GATE is:

\[U(p)=60\%\times20\%+40\%\times5\%=14\%\]

Therefore, estimating average uplift for a prefix does not requireits users to be homogeneous. What matters is that treatment and controlobservations within the prefix represent the same target population. Wedo not need to match every treated user to a control user with identicalfeatures. Under ideal randomized assignment, the two arms have the samecovariate distribution at the population level:

\[X\mid(T=1,S_p=1)\ \overset{d}{=}\ X\mid(T=0,S_p=1)\]

Covariate balance alone is not the identification condition; theessential requirement is that treatment assignment remain independent ofthe potential outcomes within the selected population. Thisrequires the model score to depend only on pre-treatment features, withtreatment remaining randomized in the evaluation sample and theassignment probability constant within the prefix. At thepopulation level, an ideal RCT satisfies:

\[T\perp\left(Y(1),Y(0)\right)\mid S_p=1\]

Together with consistency, SUTVA, and the assumptions discussedearlier, this gives:

\[E[Y\mid T=1,S_p=1]-E[Y\mid T=0,S_p=1]=U(p)\]

Cumulative Gain Curve andAUUC

If the top $p$ fraction hasaverage uplift $U(p)$, the cumulativegain from treating only that fraction, normalized by the fullpopulation, is:

\[G(p)=p\cdot U(p)\]

For a population of $N$ users, theexpected absolute total increment is $N\cdotp\cdot U(p)$. Using $G(p)$rather than the absolute total prevents the metric from scaling linearlywith the evaluation-set size.

For example, suppose the population contains 1,000 users and the top10% has an average uplift of 20%. Then:

\[G(10\%)=10\%\times20\%=2\%\]

Relative to all 1,000 users, the policy produces a normalizedcumulative gain of 2 percentage points. If $Y$ is a binary response, this correspondsto an expected absolute gain of $1000\times2\%=20$ responses.

The cumulative gain curve begins at $G(0)=0$ and reaches the following endpointat full coverage:

\[G(1)=ATE\]

This is the population-level endpoint. In a finite test set, theempirical curve ends at $\hatG(1)=\widehat{ATE}$.

Under random ranking, the expected average uplift of every prefix isthe ATE, so the random cumulative-gain baseline is a diagonal line:

\[G_{\mathrm{rand}}(p)=p\cdot ATE\]

The shape of the cumulative gain curve depends on the treatmenteffect of the users newly included as coverage expands. Let $\tau(p)$ denote the local treatment effectaround ranking quantile $p$.Then:

\[G'(p)=\tau(p)\]

The curve rises when $\tau(p)>0$, plateaus when $\tau(p)=0$, and falls when $\tau(p)<0$. For a good ranking, thecurve typically rises quickly from the origin and stays above the randombaseline over most of the range. If the tail contains users withnegative uplift, the curve may peak at an intermediate coverage leveland then decline, meeting the random baseline at $p=1$.

Under the convention used in this article, AUUC is the signed areaunder the cumulative gain curve:

\[AUUC=\int_0^1G(p)\,dp=\int_0^1pU(p)\,dp\]

In practice, first compute cumulative gain from the prefixestimate:

\[\hat G(p_m)=p_m\hat U(p_m)\]

Evaluate $\hat G(p_m)$ on a grid\(0=p_0,then approximate the integral with the trapezoidal rule:

\[\widehat{AUUC}=\sum_{m=1}^{M}\frac{p_m-p_{m-1}}{2}\left(\hat G(p_m)+\hat G(p_{m-1})\right)\]

At the population level, let $\tau(q)$ denote the average treatmenteffect among users near ranking quantile $q$, rather than an observable ITE for oneparticular user. Then:

\[G(p)=\int_0^p\tau(q)dq\]

Changing the order of integration gives:

\[AUUC=\int_0^1\int_0^p\tau(q)dq\,dp=\int_0^1(1-q)\tau(q)dq\]

Because the weight $1-q$ decreaseswith ranking position, users nearer the top contribute more to AUUC. Aranking that places larger local treatment effects earlier thereforeachieves a higher AUUC. This statement describes an unobservablepopulation target; differences between treatment and control outcomemeans in a finite test set are only noisy estimates of it.

Qini Coefficient

AUUC includes the contribution of the treatment’s overall averageeffect. Even under random ranking, the cumulative gain curve encloses anarea:

\[\mathbb E[AUUC_{\mathrm{rand}}]=\int_0^1p\cdot ATE\,dp=\frac{ATE}{2}\]

Qini subtracts this random baseline and answers: how muchadditional gain does the model ranking deliver relative to randomtargeting?

Define the Qini curve as:

\[Q(p)=G(p)-G_{\mathrm{rand}}(p)=p\left(U(p)-ATE\right)\]

The Qini coefficient is the signed area between this curve and thezero line:

\[\begin{aligned}Qini&=\int_0^1Q(p)\,dp \\&=\int_0^1p\left(U(p)-ATE\right)dp \\&=AUUC-\frac{ATE}{2}\end{aligned}\]

Under random ranking, the expected Qini is 0. A positive Qini meansthe ranking is better than random overall; a negative Qini means it isworse. Because the model curve may cross the random baseline atdifferent coverage levels, the sign of the overall Qini cannot beinferred from a single quantile.

The average uplift curve and cumulative gain curve are pointwisetransformations of one another through $G(p)=pU(p)$, so they contain the samepointwise information. Their areas, however, are not equal:

\[\int_0^1U(p)dp\neq\int_0^1pU(p)dp\]

How Should These Metrics BeRead?

The following figure summarizes the two curves and the two area-basedmetrics:

Curve or metric	Definition	Main question it answers
Average uplift curve	$U(p)$	At this coverage level, what is the average uplift of the selectedpopulation?
Cumulative gain curve	$G(p)=pU(p)$	At this coverage level, how much cumulative increment has beengenerated?
AUUC	$\int_0^1G(p)dp$	Within the same evaluation population and treatment definition, howwell does the model rank users across coverage thresholds?
Qini	$\int_0^1(G(p)-pATE)dp$	How much more does the model ranking contribute than randomtargeting?

AUUC and Qini summarize ranking performance across coveragethresholds; neither is the business value of one specific deploymentpolicy. If the online system can cover only the top $p^*$ fraction, the relevant quantity is$G(p^*)$, combined with treatmentcost to calculate net value.

Comparisons between models or experiments also require the followingconventions to remain consistent:

Outcome and scale: uplift in 7-day payment rate anduplift in 7-day GMV are measured on different scales
Target-population distribution: heterogeneity maydiffer across regions, time periods, or eligibility rules
Business definition: including refunds or filteringabnormal orders changes the result
Curve definition and normalization: verify whetherthe y-axis is average uplift, population-normalized cumulative gain, orabsolute gain, and whether the value is divided by the perfect-curvearea
Evaluation uncertainty: sample size does not changethe theoretical target of a normalized metric, but it does affectestimation variance and confidence intervals

Finally, distinguish experimental allocation ratios from causalidentification. With randomized treatment and a constant assignmentprobability, a prefix difference in means can estimate the treatmenteffect even when allocation is not 1:1. Severe imbalance such as 9:1,however, leaves too few observations in the smaller arm and increasescurve variance. If propensity varies with features—or if the data areobservational—a simple difference in means is generally unreliable; useIPW, Hájek, or doubly robust estimators instead. Extreme propensitiescan themselves inflate variance through large weights, so weightstabilization, clipping, or overlap restriction may also be needed.

A Real Strategy OptimizationCase

The previous sections mainly focused on theory and methods. Now letus shift the perspective from the model itself back to a more generalstrategy optimization framework.

Whether it is coupon distribution in e-commerce, advertisingincentives, live-stream regulation, or traffic allocation in recommendersystems, the underlying question is the same: for a given user, is itworthwhile to apply a certain intervention?

These problems can all be abstracted into a unified gain-costtrade-off framework:

Gain: the core business value we hope to improveafter intervention
Cost: the resource consumption, side effects, orlocal business loss caused by the intervention

The method itself does not depend on any particular vertical. Whatreally changes across businesses is only how the gain metric and thecost metric are defined.

Scenario	Treatment	Gain metric	Cost metric
E-commerce marketing	Send coupons, add subsidies, increase touch frequency	Order rate, GMV, 7-day LT	Coupon cost, subsidy spending, gross-margin loss
Ad delivery	Raise bids, increase exposure, give incentives	Clicks, conversions, ad revenue	Traffic occupancy, subsidy cost, UX degradation
Content / live-stream distribution	Increase or decrease exposure of certain content types, adjusttraffic share	Retention, sessions, duration, long-term value	Revenue decline in sub-businesses, ecosystem metricfluctuations

If we only stare at a single gain metric, the strategy is easy todistort. Only when gain and cost are modeled and decided together doesthe strategy become meaningful for online deployment.

Overall Pipeline

A complete uplift strategy pipeline can usually be abstracted asfollows:

Construct treatment / control data through randomizedexperiments
Train uplift models to estimate each user’s incremental gain andincremental cost
Under budget or other constraints, convert model scores intoexecutable decisions
Continuously monitor online and update the strategy dynamically

Data Construction

RCT / Switchback experiment design

There is no single form of experiment. Common designs include:

User-level randomized experiments: suitable for independentlyapplied interventions such as coupons and ad incentives
Switchback Experiments: suitable for interventions at the supply,traffic, or time-window level
Bucketed gray-release experiments: suitable for gradually scalingonline strategies

All of them share the same goal: make treatment assignment as randomas possible, thereby reducing selection bias and improving thecredibility of uplift estimation.

When running these experiments, there are at least three points thatrequire special attention:

Whether the randomization truly covers key user segmentsevenly
Whether external traffic strategies or business campaigns interfereduring the experiment
Whether the sample size is large enough to support learningheterogeneous treatment effects

Many uplift projects fail not because of the model, butbecause the experiment design is not clean enough.

Feature and Label Design

In a general uplift project, features usually cover multiplecategories such as users, behaviors, and context. For example:

Feature category	Example features	Business meaning
Basic user features	Age, gender, registration age	Basic user attributes
Historical transaction features	Number of orders, AOV, repurchase interval	Commercial value and purchase habits
Ad interaction features	Impressions, clicks, conversions, incentive claims	Advertising sensitivity
Content consumption features	Duration, completion rate, number of interactions	Content preference and attention allocation
Price sensitivity features	Preferred price band, discount usage rate	Sensitivity to subsidies and promotions
Device and environment features	Device model, network, region, time period	External constraints and scenario differences
Traffic context features	Entry point, slot, slot competition	Current supply environment
User profile and segmentation	Interest tags, value tier, risk tags	User categorization
Social relationship features	Following, fans, mutual follows, sharing ties	Social diffusion potential
Trend features	7d/30d differences, ratios, slopes	State changes

There is an important practical lesson here: the key in upliftfeature engineering is not only improving response prediction, but alsoexposing heterogeneity—i.e. “who is more sensitive to the intervention.”Therefore, features that reflect trends, state transitions, anddifferences in consumption structure are often more important thanstatic user profiles.

Under this general framework, it is usually advisable to split labelsinto two types.

1. Gain Label

Represents the incremental benefit on the business’s core objectiveafter intervention.

Examples:

E-commerce: 7-day order rate, GMV, repurchase, long-term value
Advertising: CTR, conversion rate, ad revenue, advertiser ROI
Content / live streaming: retention, effective sessions, watch time,long-term active value

2. Cost Label

Represents the resource consumption or side effects that must be paidafter intervention.

Examples:

E-commerce: coupon cost, subsidy consumption, gross-margin loss
Advertising: traffic occupancy, subsidy cost, decline in userexperience
Content / live streaming: decline in revenue of a sub-business,supply-ecosystem volatility, duration migration loss

This is crucial: many strategies only predict gain and do not predictcost. As a result, once deployed online, they often run into the problemthat “the primary metric improved, but the business side effects weretoo large.” Modeling gain and cost separately is essentially preparationfor constrained optimization downstream.

3. Multi-label scenarios

When there are multiple optimization targets, there are oftenmultiple labels as well (for example, in LT optimization the cost labelmay simultaneously affect both watch time and revenue). In that case, weneed to consider how to merge multiple labels into one so that the modelcan learn more easily and downstream planning can be solved moreconveniently. A common approach is to directly use the raw labels andalign their scales with manually chosen weights, as follows:

\[y = w_1 y_1 + w_2 y_2 + w_3 y_3\]

But this approach has several obvious problems:

Hyperparameters are hard to tune
Strongly affected by outliers
Once the distribution drifts, stability becomes poor

In practice, a more common method is percentile normalization,i.e. use each sample’s relative position in the training set toreplace the raw value itself:

\[y = w_1 * \text{percentile\_rank}(y_1) + w_2*\text{percentile\_rank}(y_2) + w_3 * \text{percentile\_rank}(y_3)\]

The advantages are quite clear:

The $\text{percentile\_rank}$function maps raw labels with different units into a fixed range such as[0, 1], making learning easier
The exchange rate among different objectives becomes morecontrollable. By keeping the values of $w$ the same, the objectives can be givenequal weight; or one can manually define an exchange rate, and itbecomes less sensitive to score drift in any specific target (forexample, if target A is uniformly overestimated by 10x)
More robust to outliers
Better aligned with downstream ranking-based decisions

This is a classic engineering trade-off: in real businesssettings, the model often does not need to estimate absolute returnsperfectly; what matters more is ranking relative prioritycorrectly.

Model Selection andEvaluation

If we want a relatively robust heterogeneous-effect learner acrossmultiple business scenarios, Causal Forest is often a good startingpoint. The reasons were already discussed in the cross-method comparisonabove, so I will not repeat them here.

The offline evaluation metrics were also discussed earlier. Inpractice, what matters more is whether AUUC and Qini are consistentbetween the training and test sets, and whether uplift ranking is stableacross different buckets.

There are two phenomena that occur frequently and are easy tomisread:

1. The absolute AUUC of a sparse cost label may be verysmall

If a cost metric contains many zeros and is extremely sparse, theneven if the model ranks correctly, the absolute AUUC may still be small.This does not necessarily mean the model is useless; it may simplyreflect the low information density of the label itself.

2. AUUC for some cost-related metrics may benegative

This often appears in “suppressive interventions,” such as reducingexposure of a certain content type, compressing a certain subsidy, orlowering the traffic share of a certain format. In such cases, thepurpose of the treatment is to sacrifice a local metric in exchange foroverall gain, so a negative uplift on the cost dimension may actuallymean the direction is working as intended.

Therefore, when evaluating uplift models, we should not look at anyone gain or cost metric in isolation. Instead, we should interpret theirdirectionality and trade-offs together with the strategic objective.

Online Decision-Making

At this point, we have trained two models to estimate $\Delta \text{gain}$ and $\Delta \text{cost}$ before and afterapplying treatment.

But what creates real business value is not simply assigning anuplift score to each user. The real problem is to make the optimalchoice between Gain and Cost.

Optimization ProblemDefinition

We can naturally formulate the following constrained optimizationproblem.

Suppose there are $n$ users, andafter intervention on user $i$:

The estimated business gain is $\text{gain}_i$
The estimated business cost is $\text{cost}_i$

Define the decision variable:

\[x_i \in \{0, 1\}\]

where $x_i = 1$ means applying theintervention to user $i$.

If the budget or business-loss constraint is $C$, then the optimization objective can bewritten as:

\[\begin{aligned}\max_{x_i} \quad & \sum_{i=1}^{n} x_i \cdot \text{gain}_i \\\text{s.t.} \quad & \sum_{i=1}^{n} x_i \cdot \text{cost}_i \le C \\& x_i \in \{0, 1\}\end{aligned}\]

This is essentially: “under limited cost, choose the people mostworth intervening on.”

To solve this directly, we can construct the followingLagrangian:

\[L(x, \lambda) = \sum_{i=1}^n x_i (\text{gain}_i - \lambda \cdot\text{cost}_i) + \lambda C\]

To maximize $L$, for eachindependent $i$, the decision logicis:

If $(\text{gain}_i - \lambda \cdot\text{cost}_i) > 0$, i.e. $\frac{\text{gain}_i}{\text{cost}_i} >\lambda$, then choose $x_i =1$
If $\frac{\text{gain}_i}{\text{cost}_i}< \lambda$, then choose $x_i =0$

Here $\lambda$ can be interpretedas the shadow price of cost.

This conclusion is important because it shows that under a given costconstraint, ranking by gain per unit cost (ROI) has an optimizationfoundation.

Approximate Solution:Greedy Strategy

Directly using the Lagrangian has two engineering inconveniences:

It requires an explicit budget $C$. But when cost is formed by fusingmultiple metrics and then normalized, $C$ often loses its physical meaning(unlike coupon scenarios, where the budget is explicit money), so onecan only pick a value heuristically from the distribution
The solution depends on the absolute accuracy ofgain and cost. But after label normalization, sample-selection bias, andother adjustments, uplift model outputs often have systematic offsets.Once $\lambda$ is fixed, if the modeloverestimates gain the system overspends; if it underestimates, thebudget is left unused

In engineering practice, a greedy strategy is more common:

Compute $\text{ROI}_i =\dfrac{\text{gain}_i}{\text{cost}_i}$ for each user
Sort users by ROI from high to low
Accumulate cost from the top until budget $C$ or a population-ratio threshold isreached

The greedy strategy and the Lagrangian are equivalent insolution: if we sort users by ROI and take them from highest tolowest, then the ROI of the last selected user is the implicit optimalshadow price $\lambda^\star$. Allusers above that point satisfy the Lagrangian optimality condition $\text{gain}_i - \lambda^\star\,\text{cost}_i >0$. In other words, the greedy method uses ranking plusaccumulation to implicitly perform dual ascent and find $\lambda^\star$, avoiding the needto solve a nonlinear equation explicitly.

Compared with explicit Lagrangian solving, the greedy strategy hastwo engineering advantages:

1. More robust to estimation bias

Explicit Lagrangian solving requires the absolute values of gain andcost to be accurate; otherwise a fixed $\lambda$ leads to overspend or budgetunderuse. By contrast, greedy selection only requires therelative ranking to be correct. If we truncate by user quantileor by a dynamic budget pool, then no matter how the scores drift, westill pick the users who are currently most worth treating.

2. More efficient online computation

Greedy solving reduces to “score + sort + threshold comparison,”which can be precomputed offline or nearline, and is much faster thansolving nonlinear equations online.

SmoothTreatment: From Hard Thresholds to Soft Intensity

Whether we use the Lagrangian or a greedy strategy, the result so faris a hard-threshold decision: if $\text{ROI} > \lambda^\star$, fullyintervene; otherwise, do not intervene at all. In many businesses, this0/1 decision is suboptimal for two reasons:

1. It removes room for exploration

If the treatment is a strong intervention such as “do not show acertain content genre,” then for high-ROI users, completely notshowing it means the system will never observe those users’true feedback to that genre. That permanently eliminates exploration forthose users, which is often unacceptable for businesses that still wantto expand penetration.

2. Integer solutions can waste budget

For example, suppose the budget is $C =2.5$ and there are two users:

User A: $\text{gain}=10$, $\text{cost}=2$, $\text{ROI}=5$
User B: $\text{gain}=8$, $\text{cost}=2$, $\text{ROI}=4$

Under a hard threshold (greedy or Lagrangian, same result): choose Afirst (cost = 2 ≤ 2.5); when considering B, the accumulated cost wouldbecome 4 > 2.5, so B must be discarded. The finalgain is 10, and the remaining 0.5 budget is wasted.

If we allow the treatment intensity to be shared (continuous $x_i \in [0,1]$, interpreted as aprobability or intensity ratio), then we could allocate cost 1.5 to A(75% intensity) and 1 to B (50% intensity). Assuming gain and cost scaleproportionally, the total gain becomes $10\times 0.75 + 8 \times 0.5 = 11.5 > 10$.

The form of theoptimal LP-relaxed solution

LP Relaxation is one of the most classical approximatesolving techniques in combinatorial optimization—it relaxes theinteger constraint $x_i \in \{0,1\}$into the continuous constraint $x_i \in[0,1]$. The original problem then becomes a linear program,which can be solved exactly by KKT conditions or the simplex method.

The problem we face here is a knapsack problem. For the fractionalknapsack, the optimal solution is exactly the greedy solution that sortsby ROI; this is a classical result with a rigorous proof. For the LPrelaxation of the 0/1 knapsack, the optimal solution contains at mostone fractional variable, and the gap to the integer optimum isbounded.

By relaxing the integer constraint $x_i\in \{0,1\}$ to the continuous range $x_i \in [0,1]$, and introducing the dualvariable $\lambda \ge 0$ for thebudget constraint, the KKT conditions yield the following optimalsolution:

\[x_i^\star =\begin{cases}1, & \text{ROI}_i > \lambda^\star \\\in [0,1], & \text{ROI}_i = \lambda^\star \\0, & \text{ROI}_i < \lambda^\star\end{cases}\]

That is, users with ROI higher than the shadow price $\lambda^\star$ are fully turned on, whilethose below it are fully turned off. This is still a step function, butit gives a key structural property: the optimal treatmentintensity is a monotone non-decreasing function of ROI.

LP relaxation is especially suitable for budget-constrained upliftproblems for several reasons:

The structure of the solution is clear: the stepform above directly matches the business intuition of “sort by ROI andtake the top-K,” so model scores can be directly converted intoexecutable strategies
It naturally supports smoothing: continuous $x_i$ can be interpreted as “probability /intensity,” which maps perfectly to smooth treatments in engineering(coupon probability, recommendation-score weighting, ranking penaltyintensity, etc.), instead of requiring an additional “rounding to 0/1”step like integer solutions do
Equivalent to greedy: for fractional knapsack, theLP solution is exactly the greedy ROI-sorting solution, so the greedystrategy in the previous section is itself the exact LP-relaxationsolution under the knapsack structure and does not require an additionalsolver

An inherentproperty of the LP optimum: monotonicity

The KKT form above already implies that $x_i^\star$ is monotone non-decreasing in$\text{ROI}_i$, but this propertydoes not depend on any particular functional form. It is aninherent property of any continuous-allocation problemunder a budget constraint, and it can be rigorously proved using anexchange argument.

Consider two users $i, j$ (with$\text{cost}_i, \text{cost}_j >0$). Suppose $\text{ROI}_i >\text{ROI}_j$, but assume for contradiction that in the optimalsolution $x_i^\star < x_j^\star$.We make a small budget transfer: take back $\varepsilon$ units of cost from $j$ and give them to $i$:

Decrease $x_j$ by $\dfrac{\varepsilon}{\text{cost}_j}$, whichfrees $\varepsilon$ units ofcost
Increase $x_i$ by $\dfrac{\varepsilon}{\text{cost}_i}$, whichconsumes the same $\varepsilon$ unitsof cost

Total cost is unchanged, so the budget constraint is still satisfied.The change in the objective is:

\[\Delta \text{Obj} = \frac{\varepsilon}{\text{cost}_i}\cdot\text{gain}_i- \frac{\varepsilon}{\text{cost}_j}\cdot\text{gain}_j = \varepsilon\cdot (\text{ROI}_i - \text{ROI}_j) > 0\]

So we can strictly improve the objective, which contradicts theassumption that the original allocation was optimal. Therefore theoptimum must satisfy $x_i^\star \gex_j^\star$.

This exchange argument does not assume any specific functional form.The conclusion is an objective fact: as long as budget can beallocated continuously and ROI is well-defined (cost > 0), theoptimal allocation must be monotone non-decreasing in ROI.Fractional knapsack, network-flow allocation, and ad bidding all followthe same mechanism.

Choosing a mapping function

The KKT step form cannot be deployed directly (it isnon-differentiable and leaves no exploration), so in engineering we lookfor a function $f(\text{ROI})$ toapproximate it. This function must satisfy:

Monotone non-decreasing—this is forced by theexchange argument above; otherwise it is not a valid approximation tothe LP optimum
Smooth and differentiable—convenient for end-to-endtraining and gradient optimization
Range $[0,1]$—consistent with thesemantics of a probability / intensity
Transition around $\text{ROI} =\lambda^\star$—to preserve the shape of the stepsolution

Many function families satisfy these conditions:

Function family	Form	Comment
Sigmoid	$\sigma\!\big(\alpha(\text{ROI} -\lambda^\star)\big)$	Most common; $\alpha$ controlssteepness
Hardsigmoid / piecewise linear	$\text{clip}(\alpha(\text{ROI} -\lambda^\star) + 0.5,\,0,\,1)$	Cheaper to compute
Any monotone distribution CDF	$F(\text{ROI})$	More natural probabilistic interpretation (e.g. truncatednormal)
Softplus composition	$1 -e^{-\text{softplus}(\alpha(\text{ROI}-\lambda^\star))}$	More flexible for tail control

In engineering, sigmoid is usually chosen mainly because theform is simple, differentiable everywhere, and easy to tune inpractice—not because it is mathematically “more optimal.”Replacing it with any other monotone smooth function leads to the sameunderlying conclusion.

At the end of the day, what often takes effect online is a simplerule: “the higher the ROI, the stronger the treatment intensity.”

This also makes intuitive sense: under a budget constraint,allocate more resources to people with higher marginal returns.A high ROI means the intervention is more cost-effective for that user,so naturally that user should receive more treatment intensity. This issimply the law of resource allocation under constrained optimization,and it is the same principle by which higher bidders obtain moreresources in an auction.

Therefore, the online advantages of smooth mappings are often:

1. Preserve exploration space and mitigate feedbackloops
2. Use the budget more fully (avoiding waste caused by hardinteger discard)
3. Allocate different treatment intensities to different users,enabling finer-grained intervention

Adaptive Distributions

After a strategy is deployed, the data distribution is very likely tochange.

Common issues include:

1. Drift in the uplift ROI distribution

A common solution is to normalize the scores again and map them intoa stable interval [a, b], so that thresholds and quantilesremain more controllable.

2. Long-term right-shift or left-shift in businessmetrics

For example, AOV, conversion value, watch time, ad bids, and similarmetrics may keep shifting as the business evolves. In that case, themodel score itself may still be fine, but the decision thresholds andthe budget mapping gradually become distorted.

So after an uplift strategy goes online, we should not only askwhether the model has been updated. We should continuously monitor:

Whether the score distribution has drifted
Whether population coverage has become abnormal
Whether the gain / cost ratio has changed
Whether side effects of the strategy have expanded

The Feedback-Loop Trap

After a strategy goes online, the easiest trap to fall into isdirectly retraining the model on online data. This is aproblem that is unique to uplift and more serious than in CTR/CVRmodeling, so it is worth discussing separately.

Once an online uplift strategy is deployed, treatment assignment isno longer random: high-score users are almost always treated, whilelow-score users are almost never treated. This directly breaks two keyassumptions behind uplift estimation:

Overlap: $0 < P(T=1\mid X=x) < 1$ → high-score populations become almost all$T=1$, low-score populations becomealmost all $T=0$, and the overlapregion disappears
Unconfoundedness: $T\perp (Y(1), Y(0)) \mid X$ → treatment assignment itself becomesa function of the model score, so confounding is introduced

If we directly retrain on this batch of “data already selected by thestrategy,” the model will learn the strategy’s own selectionbias as if it were a causal effect. In the next round, thescores become more extreme, interventions become more concentrated, andthe bias gets amplified further—a classic feedback loop.

CTR and CVR models have a related issue as well, but for uplift it ismuch more severe:

Dimension	CTR / CVR	Uplift
Learning target	$P(Y \mid X)$, a singleconditional distribution	$E[Y(1) - Y(0) \mid X]$, whichrequires two counterfactual distributions
Type of bias	Even with exposure bias, the model can still learn; it mainlyincreases variance	Once overlap is broken, the effect becomes directlyunidentifiable; this is bias, not variance
Signal strength	Labels are dense and signal is strong	Uplift is the difference of two numbers; the signal itself is 1–2orders of magnitude weaker
Error accumulation	One-directional accumulation in $P(Y \midX)$	Two-directional accumulation in $\hat{\mu}_1 - \hat{\mu}_0$, and strategydrift accelerates it

Intuitively: even with selection bias, a CTR model is at least stilllearning “will this group click?” But once an uplift model losesoverlap, what it learns is not the causal effect atall, but the strategy selection rule itself.

Common engineering corrections include the following:

Method	Idea	Cost
Keep a random holdout bucket	Always reserve 5%–10% of traffic for random assignment online; useonly this part to retrain or calibrate	Sacrifice a small amount of online revenue in exchange for continuedidentifiability. The most common industrial solution
IPW (Inverse Probability Weighting)	Weight samples by the actual online assignment probability $\hat{e}(x)$ to correct selection bias	Requires $\hat{e}(x)$ to stayaway from 0/1, otherwise variance explodes
Doubly Robust	Use both the response model and the propensity score; if one isbiased, the other can still compensate	More complex to implement, but the best robustness
Periodic full RCT	Periodically pause the strategy and collect a fully randomizeddataset	Larger short-term business volatility; often used in early stages orperiodic recalibration

In practice, the holdout random bucket is usually the mostcost-effective solution: it preserves the identifiability of anRCT without requiring frequent pauses to the strategy. At the same time,the holdout bucket can also naturally be used for model A/B comparisons,Qini-curve evaluation, threshold calibration, and more.

The simplest rule to remember is: the training data for uplift modelsmust preserve randomness in treatment assignment. Themodel cannot directly train on its own policy-generated data, otherwiseit is reinforcing bias rather than learning causality.

MultipleTreatments and Continuous Treatments

Everything discussed so far has focused mainly on a single binarytreatment. But in real business settings, more complex forms arecommon:

Multiple Treatments: multiple discrete interventiontypes exist (such as coupons with different face values, or different adcreatives)
Continuous Treatment: the intervention differs instrength or dosage (such as discount size, subsidy amount, or exposurefrequency)

These two classes of scenarios differ substantially from the binarycase in identification assumptions, modeling methods, and decisionsolving, so we discuss them separately below.

Shared CausalIdentification Assumptions

The three assumptions for binary treatment (unconfoundedness,overlap, SUTVA) need corresponding extensions:

Unconfoundedness: must hold for all$t$

\[\{Y(t)\}_{t \in \mathcal{T}} \;\perp\; T\;\big|\; X\]

That is, conditional on $X$,treatment assignment $T$ must beindependent of all possible potential outcomes. In practice, thisusually requires multi-arm RCTs (for multipletreatments) or dose randomization (for continuoustreatment).

Overlap: extends to requiring observed samples forevery $t$

Multiple treatments: $P(T=t \mid X=x)> 0, \quad \forall t \in \{0, 1, \dots, K\}$
Continuous treatment: conditional density $f_{T \mid X}(t \mid x) > 0, \quad \forall t \in\mathcal{T}$

This is one of the easiest assumptions to violate in real businesssettings. For example, if some treatment is only assigned to specificpopulations by the online strategy, then $P(T=t \mid X=x)$ is 0 for all otherpopulations, and the model cannot identify $\tau(x, t)$ on those populations.

Generalized Propensity Score (GPS): this is theextension of the binary propensity score $P(T=1 \mid X)$

Multiple treatments: $e_t(x) = P(T=t \midX=x)$, one for each $t$
Continuous treatment: $e(t, x) = f_{T\mid X}(t \mid x)$, a conditional density

GPS is the basis for later estimators such as IPW, DR, and weightedregression (Imbens 2000; Hirano & Imbens 2004).

Multiple-Treatment Scenarios

When multiple intervention choices exist, the problem changes from“whether to intervene” to “which intervention should be used.”

Problem Definition

Suppose there are $K+1$ treatmentvalues $t \in \{0, 1, \dots, K\}$,where $t=0$ means no intervention.Each treatment corresponds to one potential outcome $Y_i(t)$, and the individual treatmenteffect relative to no intervention is $\tau_i(t) = Y_i(t) - Y_i(0)$.

Since the ITE $\tau_i(t)$ isunobservable, the actual modeling target is theCATE:

\[\tau(x, t) = E[Y(t) - Y(0) \mid X = x],\quad t \in \{1, \dots, K\}\]

The optimal treatment decision is defined on top of the estimatedCATE:

\[\hat{t}^\star(x) = \arg\max_{t \in \{0,1, \dots, K\}} \hat{\tau}(x, t)\]

where $\hat{\tau}(x, 0) \equiv0$.

Common Modeling Methods

1. One-vs-All (OVA)

Decompose the multiple-treatment problem into $K$ binary uplift subproblems, eachestimated independently:

\[\hat{\tau}_k(x) = \hat{E}[Y(k) - Y(0)\mid X=x], \quad k=1,\dots,K\]

Then choose the treatment with the largest estimated increment: $\hat{t}^\star(x) = \arg\max_k\hat{\tau}_k(x)$.

The advantage is that it can directly reuse existing binary upliftmodels. But the disadvantages are deeper than merely “training $K$ models”:

Low sample efficiency: when training $\hat{\tau}_k$, only treatment $k$ and control samples are used; data fromother treatment groups are discarded
Biases are not comparable in the final horse race:the $K$ independent models may eachhave biases of different directions and scales, and the argmax ispolluted by those relative biases—if one $\hat{\tau}_k$ is systematicallyoverestimated, it may always be selected
It does not enforce $\hat{\tau}(x, 0) = 0$

2. Multivalued S-Learner

Feed the treatment as a multi-valued categorical feature into asingle model:

\[\hat{\mu}(x, t) = \hat{E}[Y \mid X=x,T=t]\]

At prediction time, enumerate all $t$ and choose the largest uplift:

\[\hat{t}^\star(x) = \arg\max_t\big(\hat{\mu}(x, t) - \hat{\mu}(x, 0)\big)\]

This is the multivalued version of the S-Learner. It requiresunconfoundedness for all $t$ and theextended overlap assumption. Its advantage is that it can learn sharedstructure across treatments and use all samples for training; itsdisadvantage is inherited from the S-Learner—the treatment signal may bewashed out by strong regularization.

3. Pairwise Comparison

Estimate the relative advantage for every pair $(j, k)$:

\[\hat{\tau}_{jk}(x) = \hat{E}[Y(j) - Y(k)\mid X=x]\]

This requires $\binom{K+1}{2} =O(K^2)$ models. The pairwise results can then be aggregatedusing methods such as Borda count or Bradley-Terry.

The main risk is broken transitivity: one may get acycle such as $\hat{\tau}_{12} >0$, $\hat{\tau}_{23} > 0$,but $\hat{\tau}_{13} < 0$, due toinconsistencies from independent estimation. So when $K \ge 4$, pairwise modeling is usually notused directly.

4. DR-Learner / GPS-weighted methods (more modernapproaches)

Directly construct a doubly robust pseudo-outcome for eachtreatment:

\[\tilde{Y}_i(t) = \hat{\mu}(X_i, t) +\frac{\mathbb{1}\{T_i=t\}}{\hat{e}_t(X_i)} \big(Y_i - \hat{\mu}(X_i,t)\big)\]

Then regress $\tilde{Y}_i(t) -\tilde{Y}_i(0)$ to obtain $\hat{\tau}(x, t)$. The advantage is thatconsistency is guaranteed as long as either $\hat{\mu}$ or $\hat{e}_t$ is estimated well, and sampleefficiency is higher than OVA. Causal Forest and EconML both providemultiple-treatment variants.

Joint decision under abudget constraint

A more realistic business problem is: under a budget constraint,decide both “which users should be treated” and “which treatment eachuser should receive.” Let the decision variable $x_{it} \in \{0,1\}$ indicate whethertreatment $t$ is applied to user$i$ ($t=0$ means no treatment, and $\text{gain}_i(0) = \text{cost}_i(0) =0$):

\[\begin{aligned}\max_{\{x_{it}\}} \quad & \sum_{i=1}^n \sum_{t=1}^K x_{it} \cdot\text{gain}_i(t) \\\text{s.t.} \quad & \sum_{i=1}^n \sum_{t=1}^K x_{it} \cdot\text{cost}_i(t) \le C \\& \sum_{t=0}^K x_{it} = 1, \quad \forall i \\& x_{it} \in \{0, 1\}\end{aligned}\]

The second constraint enforces that each user can receive at most onetreatment (including “no treatment”). This is a Multiple ChoiceKnapsack Problem (MCKP), which is NP-hard.

A practical approximate greedy solution is:

Enumerate all $(i, t)$ pairs(with $t \ne 0$), and compute $\text{ROI}_{it} = \text{gain}_i(t) /\text{cost}_i(t)$
Sort all pairs globally in descending ROI order
Select pairs in that order, keeping only the first selectedtreatment per user (per-user dedup), until accumulated costreaches $C$

The simple “per-user argmax + global sort” approach (first chooseeach user’s highest-ROI treatment, then sort users globally) is notoptimal for MCKP—it throws away the alternatives that have slightlylower ROI but much smaller cost. A more standard solution is to solvethe LP relaxation for $\lambda^\star$, then let each userindependently choose $\arg\max_t(\text{gain}_i(t) - \lambda^\star \cdot \text{cost}_i(t))$, andfinally use binary search on $\lambda^\star$ so that total costapproaches $C$.

Continuous-TreatmentScenarios

When the treatment is a continuous variable like “how much to do”(discount size, bid, exposure frequency), the target becomes estimatinga Dose-Response Curve (DRC).

Problem Definition

Treatment $t$ takes values in$\mathcal{T} \subseteq \mathbb{R}$.In the continuous setting, uplift has two reasonable definitions:

Absolute uplift (relative to no treatment or a baseline dose$t_0$)

\[\tau(x, t) = E[Y(t) - Y(t_0) \mid X =x]\]

This is suitable for decisions such as “on vs. off” or “increasevs. not increase.”

Marginal uplift (the gain change brought by one additionalunit of dose)

\[\partial_t \mu(x, t) =\frac{\partial}{\partial t} E[Y(t) \mid X = x]\]

This is suitable for dose optimization and finding the optimalturning point.

Both are derived from the same DRC $\mu(x,t) = E[Y(t) \mid X=x]$; the only difference is whether we careabout the integral or the derivative.

Common Modeling Methods

1. Dose-Response Network (DRNet, Schwab etal. 2020)

A neural-network structure with a shared representation and multipleheads: partition the dose space into $M$ sub-intervals $[t_m, t_{m+1}]$, and assign one head toeach interval, while all heads share the first few encoder layers:

\[\hat{\mu}(x, t) = \sum_{m=1}^M\mathbb{1}\{t \in [t_m, t_{m+1}]\} \cdot h_m(\phi(x), t)\]

The shared $\phi(x)$ greatlyimproves sample efficiency relative to independent models; within eachinterval, $h_m(\cdot, t)$ can uselinear or spline interpolation to avoid boundary jumps.

2. Continuous Meta-Learners

Extend the Meta-Learner framework to continuous $T$. Common approaches include:

Treat $t$ as an input feature inan extended S-Learner: $\hat{\mu}(x, t) =f(x, t)$
Train T-Learners at each dose quantile, then interpolate
Continuous X-Learners combined with GPS weighting

At prediction time, search over $t$ using either a grid search or gradientascent to find the optimal dose.

3. GPS weighting and IPW estimation

Use the generalized propensity score $\hat{e}(t, x) = \hat{f}_{T \mid X}(t \midx)$ to perform kernel-weighted IPW estimation:

\[\hat{\mu}(x, t) = \frac{\sum_i K_h(t -T_i) \cdot \frac{1}{\hat{e}(T_i, X_i)} \cdot Y_i}{\sum_i K_h(t - T_i)\cdot \frac{1}{\hat{e}(T_i, X_i)}}\]

where $K_h$ is a kernel withbandwidth $h$. Direct IPW can sufferexploding variance when the estimated density is small, so inengineering practice people often use:

Stabilized weights: $w_i= \hat{f}_T(T_i) / \hat{e}(T_i, X_i)$, where the numerator isthe marginal density of $T$, whichcan substantially control variance
Weight clipping: clip weights into a range such as$[0.01, 100]$
Doubly robust variants (such as DR-DRC in Kennedyet al. 2017)

4. Modern neural-network methods

VCNet (Variational Counterfactual Networks), SCIGAN, and otherarchitectures are specifically designed for continuous treatment. Theyfurther combine representation learning with GPS adjustment, and havebecome a mainstream direction in recent research.

Choosing the optimal dose

Given user features $x$, theoptimal dose under a budget constraint can be written as the followingLagrangian problem with $\lambda$:

\[t^\star(x) = \arg\max_{t \in\mathcal{T}} \big(\text{gain}(x, t) - \lambda \cdot \text{cost}(x,t)\big)\]

When $t$ is continuouslydifferentiable, the first-order condition gives:

\[\partial_t \text{gain}(x, t) = \lambda\cdot \partial_t \text{cost}(x, t)\]

That is, marginal gain equals the shadow price times marginalcost—each additional unit of dose should bring exactly enoughextra benefit to offset its extra cost. The value of $\lambda$ is recovered from the globalbudget constraint $\int t^\star(x) \, dF(x)\le C$.

In practice, this is often approximated by grid search:

Sample a discrete set $\{t_1, \dots,t_M\}$ on $\mathcal{T}$
For each user and each $t_m$,predict $\hat{\text{gain}}$ and $\hat{\text{cost}}$
Choose $\arg\max_m (\hat{\text{gain}}(x,t_m) - \lambda \cdot \hat{\text{cost}}(x, t_m))$
Use binary search on $\lambda$ sothat the global cost hits the budget

Note that here we cannot simply rank by ROI = gain /cost: under continuous dose, the optimum is characterized bythe first-order condition (matching marginal gain to marginal cost),which is not equivalent to maximizing ROI. Only when cost is linear in$t$ (i.e. $\text{cost}(x,t) = c(x) \cdot t$) does ROIranking coincide with the Lagrangian optimum.

Engineering Challenges

Challenge	Multiple Treatments	Continuous Treatment
Causal identification	Need unconfoundedness for all $t$; every $t$ must satisfy overlap $P(T=t\\|X) > 0$	Same, but overlap becomes a density condition $f_{T\\|X}(t\\|x) > 0$, which makesdensity estimation harder
Experiment design	Multi-arm RCT or stratified switchback; sample size grows roughlylinearly with $K$	Dose randomization (e.g. uniform dose sampling, or a fixed dose setwith random assignment); density coverage must be adequate
Model complexity	OVA is $O(K)$, pairwise is $O(K^2)$; joint modeling can mitigatethis	Need to learn a continuous function; GPS estimation itself isalready a nontrivial density-estimation problem
GPS-estimation stability	Discrete GPS only needs a multiclass model	Conditional density estimation (normalizing flow, kernel) isunstable in the tails; stabilized weights / clipping are oftenneeded
Decision solving	MCKP, NP-hard; approximated via LP relaxation + binary search on$\lambda$	Lagrangian first-order condition + grid search; cannot directly useROI ranking
Feedback loop	More severe than in the binary case—online strategies can cause some$(X, t)$ combinations to lack samplesfor a long time, so overlap keeps deteriorating	Same, and the bias in density estimation is further amplified byIPW

From an engineering perspective, these two types of scenarios areclearly harder to deploy than the binary-treatment case. A commonpractical approach is to first use a binary RCT to verify theexistence of an uplift signal, and only then extend to multiple orcontinuous treatments, so that we do not start with the hardestpossible setup and step into multiple traps at once.

Summary and Outlook

The core of Uplift Modeling is not predicting “who will convert,” butestimating “whose behavior will change in net terms because of theintervention.” That is why it addresses a problem much closer tobusiness decision-making: under limited budget and side-effectconstraints, reserve intervention resources for the people most worthinfluencing.

With that goal in mind, this article discussed the following issuesin sequence:

First, why traditional prediction can only answer correlation and notcounterfactuals;
Second, how potential outcomes, CATE, unconfoundedness, overlap, andSUTVA form the causal foundation of uplift;
Third, how S/T/X-Learners, Uplift Trees, and Causal Forests correspondto different modeling trade-offs;
Fourth, how AUUC, Qini, and cumulative gain curves are used to evaluatewhether the ranking is effective;
Fifth, how real-world deployment requires stitching together gain-costmodeling, budget constraints, smooth treatment, and feedback-loopcorrection into a full strategy pipeline;
Sixth, how modeling methods should be adapted in multiple-treatment andcontinuous-treatment scenarios

Precisely because of this, the real difficulty of uplift often liesnot only in the model, but in whether the experiment design is cleanenough, whether gain and cost are defined completely, whether the onlinestrategy preserves exploration, and whether retraining can avoid thecontinuous accumulation of selection bias. The model is only a middlelink; strategy optimization is the final objective.

Looking further ahead, the directions most worth deeper explorationinclude causal identification under network effects, jointdecision-making for multiple and continuous treatments, and combininguplift with contextual bandits or reinforcement learning. Binary upliftis often only the starting point; real production problems are usuallymore complex.

If I continue expanding this topic later, the engineering details Iwould most like to write separately about are: pitfalls in AUUC / Qiniimplementation, sample and feature design for Causal Forest /DR-Learner, and online usage patterns for smooth treatment and randomholdout.

References

Rubin, D. B. (1974). Estimating causal effects of treatments inrandomized and nonrandomized studies (Source). Journal ofEducational Psychology, 66(5), 688–701.
Künzel, S. R., Sekhon, J. S., Bickel, P. J., & Yu, B. (2019).Metalearners for estimating heterogeneous treatment effects usingmachine learning (PDF). Proceedings of theNational Academy of Sciences, 116(10), 4156–4165.
Wager, S., & Athey, S. (2018). Estimation and inference ofheterogeneous treatment effects using random forests (PDF). Journal of theAmerican Statistical Association, 113(523), 1228–1242.
Athey, S., & Wager, S. (2019). Estimating treatment effectswith causal forests: An application (PDF). ObservationalStudies, 5(2), 37–51.
Athey, S., & Imbens, G. W. (2016). Recursive partitioningfor heterogeneous causal effects (PDF). Proceedings of theNational Academy of Sciences, 113(27), 7353–7360.
Radcliffe, N. J., & Surry, P. D. (2011). Real-world upliftmodelling with significance-based uplift trees (PDF).Stochastic Solutions White Paper TR-2011-1.
Gutierrez, P., & Gérardy, J.-Y. (2017). Causal inference anduplift modelling: A review of the literature (PDF).In Proceedings of the 3rd International Conference on PredictiveApplications and APIs (PMLR, Vol. 67, pp. 1–13).
Hirano, K., & Imbens, G. W. (2004). The propensity scorewith continuous treatments (Source).In A. Gelman & X.-L. Meng (Eds.), Applied Bayesian Modeling andCausal Inference from Incomplete-Data Perspectives (pp. 73–84).Wiley.
Kennedy, E. H., Ma, Z., McHugh, M. D., & Small, D. S. (2017).Non-parametric methods for doubly robust estimation of continuoustreatment effects (PDF). Journal of theRoyal Statistical Society: Series B (Statistical Methodology),79(4), 1229–1245.
Schwab, P., Linhardt, L., Bauer, S., Buhmann, J. M., & Karlen,W. (2020). Learning counterfactual representations for estimatingindividual dose-response curves (PDF). Proceedings of theAAAI Conference on Artificial Intelligence, 34(4), 5612–5619.

Uplift 建模与策略优化实践

2026-05-02T23:51:23.000Z

很多业务问题表面上看是在做预测，真正要解决的却是干预决策。比如发优惠券、投广告、调整流量分发，真正的问题通常不是 “谁最可能转化”，而是对谁做干预，才能带来最大的净增量？

这两类问题的差异，决定了建模方式也完全不同。

传统预测模型擅长回答 “这个用户会不会买”、“这个用户会不会留存”；但它很难回答 “如果我发券，他会不会因此多买”“如果我减少直播曝光，他的长期价值会不会提升”。前者是相关性问题，后者是因果性问题。

Uplift Modeling的价值，就在于把优化目标从结果预测，转向对干预增量的估计。相比 “找高概率用户”，它更关注 “找高增量用户”，从而实现在资源约束下的优化目标价值最大化。

本文尝试介绍 uplift的基本原理和一个实际落地的应用场景，基本内容如下

为什么传统预测模型不适合直接指导干预策略
Uplift Modeling 背后的因果推断理论基础与常见建模方法
AUUC、Qini 等离线评估指标应该怎么理解
在通用业务策略优化场景里，如何从实验设计一路走到线上策略落地
多 Treatment 与连续 Treatment 等扩展场景的建模思路

问题定义

传统预测的局限性

传统机器学习模型通常以预测结果 $Y$为目标：

\[\hat{Y} = f(X)\]

它擅长做的是：给定用户特征 $X$，预测用户最终会不会发生某个行为。这在很多任务上是有效的，但一旦问题变成 “要不要对用户施加干预”，就会暴露出三个局限。

（1）高概率用户不等于高增量用户

假设我们要优化 “发券后购买” 的结果。传统模型通常会找出购买概率最高的人群，但这些人未必值得发券。

用户类型	不发券	发券后	是否值得干预
铁粉用户	会买	会买	不值得
可说服用户	不买	会买	值得
无望用户	不买	不买	不值得
反感用户	会买	不买	应避免

传统模型只能识别 “谁更可能买”，却无法区分这些人究竟是铁粉、可说服用户，还是反感用户。而真正值得投放资源的，往往只有第二类：因为干预才发生正向变化的人。

（2）无法分辨因果方向

在广告场景中，如果观察到 “看过广告的用户转化率更高”，这并不能说明广告提升了转化。也可能是本来就更容易转化的人，更容易被投到广告，或者更容易被系统分配到广告曝光机会。

（3）看不到反事实

做决策时，我们真正关心的是：

干预后会怎样
不干预会怎样
两者差多少

但传统预测模型通常只能看到一个已经发生的世界，而看不到 “如果当时不做这件事，会发生什么”。

而因果估计最关键的，恰恰就是这个反事实。

Uplift 在做什么

Uplift Modeling 关注的不是结果本身，而是干预带来的净变化。

对单个用户 $i$来说，我们希望估计：

\[\tau_i = Y_i(1) - Y_i(0)\]

其中：

$Y_i(1)$表示该用户接受干预（treatment）时的结果
$Y_i(0)$表示该用户不接受干预（treatment）时的结果
$\tau_i$表示干预对该用户造成的增量

于是，传统预测和 Uplift Modeling 的差别就很清晰了：

维度	传统预测模型	Uplift Modeling
核心问题	用户会不会转化？	干预能不能让用户多转化？
学习对象	结果概率	因果增量
识别目标	高概率用户	高增量用户
策略结果	可能浪费资源	更适合精细化投放

理论基础

潜在结果

从理论上看，Uplift建模最常用的基础是因果推断里的潜在结果框架（Potential OutcomesFramework）。

对任意用户 $i$，理论上都存在两个潜在结果：

$Y_i(1)$：接受干预后的结果
$Y_i(0)$：不接受干预时的结果

个体处理效应（ITE）定义为：

\[\tau_i = Y_i(1) - Y_i(0)\]

但这里有一个经典困难：对同一个用户，我们永远不可能同时观察到 “既干预又不干预” 两种状态。这就是因果推断里的Fundamental Problem of Causal Inference。

因此在实际中，我们通常不直接估计单个用户的真实ITE，而是估计条件平均处理效应（CATE）：

\[\tau(x) = E[Y(1) - Y(0) \mid X = x]\]

也就是：在特征相似的人群里，干预平均会带来多大变化。这是大多数Uplift 模型真正想学到的东西。

四类用户

从业务视角看，Uplift最大的价值之一，是帮助我们把用户从 “按结果分层” 切换成 “按干预响应分层”。常见的四象限划分如下：

用户类型	干预后行为	不干预行为	干预效果	策略建议
Persuadables	正向	负向	正向	值得干预
Sure Things	正向	正向	接近 0	无需干预
Lost Causes	负向	负向	接近 0	无需干预
Sleeping Dogs	负向	正向	负向	避免干预

这里最值得关注的，是 Persuadables；最需要规避的，是Sleeping Dogs。

很多业务策略表面上 “模型分高、投放更积极”，但如果高分用户里大量是Sure Things，资源就会被浪费；如果误伤了Sleeping Dogs，策略甚至会出现负收益。

三个假设

要让 uplift 估计具备可信度，通常至少依赖以下三个假设。

1. 无混淆性

\[(Y(1), Y(0)) \perp T \mid X\]

也就是说，在给定特征 $X$的前提下，干预分配 $T$与潜在结果独立。

说人话就是：如果 treatment是按线上策略定向施加的，而这个策略本身又和转化倾向强相关，就很容易引入混淆，导致我们分不清 “是treatment 起作用”，还是 “被施加 treatment 的人本来就更容易转化”。

所以在 uplift 场景里，通常会通过 RCT 来尽量随机化 treatmentassignment，从而降低混淆、提升可识别性。。

2. 重叠性

\[0 < P(T=1 \mid X=x) < 1\]

即对任意一类用户，都应该有机会进入实验组或对照组。每个人群都得同时有treatment 和 control 的样本，这样模型才能学得到相似人群施加treatment 前后的效用的 diff 即 CATE

3. Stable Unit Treatment Value Assumption

一个用户的潜在结果，只受自己的干预状态影响，而不受其他用户干预状态影响。

大白话说就是用的某个用户的 treatment effect，应该只受到这个用户本身的treatment 的影响

但如果别人的 treatment也会影响他，那问题就变复杂了。因为这时他的结果不再只取决于 “我有没有被干预”，还取决于如下的可能因素：我朋友有没有被干预、别的商家有没有被补贴、同一个流量池里别人有没有被干预等等

实际业务中，如果用户之间有强社交传播、资源竞争或系统级联动，这个假设可能会被破坏。

比如说研究某个人打疫苗，能不能降低他感染风险？如果只有 “自己打没打” 在起作用，那比较简单。但现实里，别人打疫苗也会影响你：你周围很多人都打了-> 病毒传播整体变弱了 -> 即使你没打，你感染风险也下降了. 这就是SUTVA 不成立。

但实际上，SUTVA在真实业务里常常不完全成立。因为很多业务天然就有联动：社交传播、资源竞争、库存约束等，以LT优化为例，不出某种体裁的内容会导致用户其他体裁的内容增加，那最终用户的LT 变化其实是受这两种体裁的变化共同影响的

所以 SUTVA往往不是 “完全成立” 或 “完全不成立”，而是：这个干扰强不强，能不能忽略。

如果干扰很弱，工程上可以近似接受；如果干扰很强，就要重新设计实验，比如说：
-按群组随机而不是按个人随机，比如说对同一个好友圈的人同时发券，而不是一部分人发，一部分人不发
- 从” 按用户随机” 改成” 按时间随机”，即不要同一时刻一部分人开treatment、一部分人不开；而是在某些时间段全量开，另一些时间段全量关

建模方法

Uplift Modeling 并没有唯一标准答案。工程上更常见的是两类方法：

Meta-Learners：把因果效应估计拆成几个监督学习子问题。如常见的各种xx-Learner
Direct Uplift Models：直接围绕 treatment effect设计模型或分裂准则。常见的是 Casual Froest 这一类方法

下面简单介绍

Meta-Learners

1. S-Learner

S-Learner 的思路最直接：把干预变量 $T$当成一个普通特征，和其他用户特征一起喂给模型。

\[\mu(x, t) = E[Y \mid X=x, T=t]\]

线上 serving 时，对同一个用户分别输入 $t=1$ 和 $t=0$，两次预测的差值就是 uplift 估计：

\[\hat{\tau}(x) = \hat{\mu}(x, 1) - \hat{\mu}(x, 0)\]

优点：

实现简单
所有样本都用于训练一个模型
适合作为 baseline 快速验证

缺点：

如果 treatment 信号弱，模型容易忽略 $T$
在强正则下容易出现 regularization bias

如果只是想快速判断 uplift 方法在业务里有没有潜力，S-Learner往往是很实用的起点；但如果真要追求更高质量的 CATE估计，它通常不是终点。

2. T-Learner

T-Learner 的想法是把实验组和对照组彻底分开，分别训练两个模型：

\[\mu_1(x) = E[Y \mid X=x, T=1]\]

\[\mu_0(x) = E[Y \mid X=x, T=0]\]

两者差值就是 uplift：

\[\hat{\tau}(x) = \hat{\mu}_1(x) - \hat{\mu}_0(x)\]

优点：

可以独立拟合干预组和对照组的不同模式
不容易像 S-Learner 一样把 treatment 信号 “抹平”

缺点：

每个模型只用到部分样本，样本利用率较低
样本不平衡时效果容易变差
两个模型误差会相互叠加

3. X-Learner

X-Learner 可以理解为在 T-Learner的基础上，进一步提高样本利用效率，尤其适合 treatment / control样本不平衡的场景。

它的核心步骤可以概括为三阶段：

3.1 训练两个响应模型

\[\hat{\mu}_1(x) = E[Y \mid X=x, T=1]\]

\[\hat{\mu}_0(x) = E[Y \mid X=x, T=0]\]

3.2 构造伪因果效应

对实验组样本：

\[D_i^1 = Y_i^1 - \hat{\mu}_0(X_i)\]

对对照组样本：

\[D_i^0 = \hat{\mu}_1(X_i) - Y_i^0\]

再分别训练两个 effect model：

\[\hat{\tau}_1(x) = E[D^1 \mid X=x]\]

\[\hat{\tau}_0(x) = E[D^0 \mid X=x]\]

3.3 按倾向性得分加权组合

\[\hat{\tau}(x) = g(x) \cdot \hat{\tau}_0(x) + (1-g(x)) \cdot\hat{\tau}_1(x)\]

其中 $g(x)$ 通常取倾向性得分 $P(T=1 \mid X=x)$。

优点：

对样本不平衡更鲁棒
往往比 S-Learner、T-Learner 有更好的 CATE 精度
对业务中的非对称实验设计更友好

缺点：

实现与调参复杂度更高
训练链路更长，诊断难度更大

Direct Uplift Models

Direct Uplift Models 指的是直接围绕 treatment effect设计分裂准则或损失函数的模型。常见的方法包括：

Uplift Tree：决策树在 uplift 场景下的改造版，用KL/欧式/卡方距离等准则分裂，目标是最大化 treatment 和 control组的分布差异
Causal Forest：Causal Tree的集成版本，分裂准则更偏统计严谨（如 CMSE、SFT），常配合 honestestimation 使用

它们和普通决策树的本质区别在于：

普通树：分裂目标围绕预测误差或分类纯度
Uplift 里的树：分裂目标围绕 treatment effect 的异质性

下面分开讲。

1. 普通决策树在分裂时在干什么

普通决策树（分类或回归）的分裂逻辑，本质上都是想让节点变得更” 纯”。常见准则有：

Gini 不纯度

\[G = \sum_{k=1}^{K} p_k (1 - p_k)\]

其中 $p_k$ 是节点中属于类别 $k$ 的样本比例。Gini越小，说明节点里类别越单一。

信息增益（基于熵）

\[H = -\sum_{k=1}^{K} p_k \log p_k\]

分裂前后熵下降越多，说明这个切分把类别” 分得更开”。

回归树常用均方误差（MSE）

\[MSE = \frac{1}{n} \sum_{i=1}^{n} (y_i - \bar{y})^2\]

分裂目标是让左右子节点内的方差尽量小，预测更集中。

从上面按个指标可以看到普通决策树在分裂时只关心一件事：把结果相似的人分到一起。它压根不关心treatment，也不关心” 干预和不干预的差异”。所以使用普通树预测” 发券后会不会买”，其实是在学” 谁更可能买”，而不是” 谁因为发券才更可能买”。

2. Uplift Tree 在分裂时在干什么

Uplift Tree 不再围绕” 结果纯度” 来分裂，而是围绕” 实验组和对照组之间的差异” 来分裂。

它的直觉是：如果一个切分能让左右两边的 treatment effect明显不同，那这个特征大概率捕捉到了” 谁对干预更敏感”。

常见的分裂准则有：

KL 散度

\[D_{KL}(P^T || P^C) = \sum_y P^T(y) \log \frac{P^T(y)}{P^C(y)}\]

欧式距离

\[D_E = \sum_y (P^T(y) - P^C(y))^2\]

卡方距离

\[D_{\chi^2} = \sum_y \frac{(P^T(y) - P^C(y))^2}{P^C(y)}\]

这三个公式看着不同，但核心逻辑是一样的：

$P^T(y)$是当前候选节点内部，实验组在结果 $y$上的分布
$P^C(y)$是当前候选节点内部，对照组在结果 $y$上的分布
分裂目标是让这两个分布差异越大越好

这里的分布不是全局统计，而是节点内的经验分布。比如在二分类购买问题里：

$P^T(1)$表示 “当前节点中，实验组用户购买的比例”
$P^T(0)$表示 “当前节点中，实验组用户未购买的比例”
$P^C(1)$表示 “当前节点中，对照组用户购买的比例”
$P^C(0)$表示 “当前节点中，对照组用户未购买的比例”

为什么分布差异能反映 uplift？

这背后有一个关键的数学联系。对于二分类问题（如用户是否购买），uplift定义为：

\[\hat{\tau} = P^T(Y=1) - P^C(Y=1)\]

也就是说，uplift 本质上就是两个分布在 $Y=1$ 这一点上的差值。

举个可以直接代入公式的例子。假设当前节点里有 200 个用户，其中：

实验组 100 人：30 人购买，70 人未购买
对照组 100 人：10 人购买，90 人未购买

那么：

\[P^T(1)=0.3, \quad P^T(0)=0.7\]

\[P^C(1)=0.1, \quad P^C(0)=0.9\]

于是这个节点的 uplift 就是：

\[\hat{\tau} = P^T(1) - P^C(1) = 0.3 - 0.1 = 0.2\]

也就是说，在这个节点里，干预让购买概率提升了 20 个百分点。

那 KL/Euclidean/Chi-square 距离和 uplift有什么关系？以欧式距离为例：

\[D_E = \sum_y (P^T(y) - P^C(y))^2 = (P^T(1) - P^C(1))^2 + (P^T(0) -P^C(0))^2\]

把上面的数字代进去就是：

\[D_E = (0.3 - 0.1)^2 + (0.7 - 0.9)^2 = 0.2^2 + (-0.2)^2 = 0.08\]

由于 $P(1) + P(0) = 1$，所以 $P^T(1) - P^C(1) = -(P^T(0) -P^C(0))$，因此：

\[D_E = 2 \times (P^T(1) - P^C(1))^2 = 2 \times \hat{\tau}^2\]

在这个例子里也能直接看到：

\[D_E = 2 \times 0.2^2 = 0.08\]

因此，最大化欧式距离等价于最大化 uplift 的平方。

KL 散度和卡方距离可以理解为 uplift的” 加权放大版”—— 它们不仅看差值大小，还考虑分布的相对位置。当 $P^C$ 接近 0 或 1 时，相同的 uplift会被赋予更大的权重。

所以这三个距离的共同逻辑是：当 $P^T$ 和 $P^C$ 差异大时，意味着 treatment对结果有更强影响，即 uplift 绝对值更大。

但要注意，这里说的是单个节点内部的差异，还不是 “一个候选切分到底好不好”。真正选切分时，比较的不是左节点或右节点谁的uplift更大，而是：切分后左右子节点的加权得分，相比父节点提升了多少。

以二分类 + 欧式距离为例，节点分数可以写成：

\[\phi(node)=D_E(node)=2\hat{\tau}_{node}^2\]

如果一个候选切分把父节点分成左右两个子节点，那么它的 split gain可以写成：

\[\text{Gain}(s)=\frac{n_L}{n}\phi(L)+\frac{n_R}{n}\phi(R)-\phi(P)\]

把上面的 $\phi(node)=2\hat{\tau}_{node}^2$代进去，可以得到：

\[\text{Gain}(s) \propto \frac{n_L n_R}{n^2}(\hat{\tau}_L-\hat{\tau}_R)^2\]

这说明：在这个设定下，真正被最大化的不是某个节点自己的uplift，而是左右子节点 uplift 差异的平方。

所以更准确地说，Uplift Tree在分裂时问的问题是：这个切分能不能把 “干预特别有用的人” 和 “干预基本没用的人” 分开，从而让左右子节点的treatment effect 尽可能不同。

举个例子来说明。假设两个候选切分产生的左右子节点样本量接近，现在要判断哪个特征更适合作为分裂点。

候选特征 A 切分后：

分组	发券组购买率	不发券组购买率	Uplift
左边	30%	10%	+20%
右边	25%	20%	+5%

候选特征 B 切分后：

分组	发券组购买率	不发券组购买率	Uplift
左边	28%	18%	+10%
右边	27%	17%	+10%

特征 A 的左右 uplift 差异达到了 15%（20% - 5%），而特征 B 的左右uplift 几乎一样（都是 10%）。如果左右样本量相近，那么 split gain近似正比于 $(\hat{\tau}_L-\hat{\tau}_R)^2$，于是：

特征 A 的 split gain更大，因为它真的把人群分成了 “对券敏感” 和 “对券不太敏感” 两类
特征 B 虽然两个子节点内部都存在正uplift，但左右几乎没有差异，因此它没有真正把异质性切出来

所以 Uplift Tree 会偏好特征 A。它偏好的不是 “某个节点uplift 尽量大”，而是 “这个切分之后，左右子节点的 uplift 尽量不一样”。

如果换成普通决策树，treatment信息会被直接混进总体购买率里。这样即使某个切分明显拉开了uplift，它也未必会被识别出来。比如上面两个切分只看总体购买率时：

特征 A 左边购买率：(30%+10%)/2 = 20%
特征 A 右边购买率：(25%+20%)/2 = 22.5%
特征 B 左边购买率：(28%+18%)/2 = 23%
特征 B 右边购买率：(27%+17%)/2 = 22%

这些总体购买率只能反映 “谁更容易买”，却不能直接回答 “谁更会因为发券而改变”。

一句话总结就是：普通树让节点里的结果更纯（谁更可能买）；Uplift树让左右子节点的 treatment effect 更不一样（谁更会被改变）

3. Causal Forest 在分裂时在干什么

Causal Forest 可以理解为 Causal Tree的集成版本，也是很多真实业务里比较常用的一类方法。它的核心思想不是简单地” 给用户打分”，而是：对于目标用户$x$，自动找到一批和他在 treatmenteffect 上更相似的邻域样本，再在这个局部邻域里估计 CATE。

理论背景：CMSE 和 SFT

上面讨论的 KL / Euclidean / Chi-square，主要是在讲 UpliftTree这一路方法：它从 “实验组与对照组的结果分布差了多少” 这个角度来评价节点和切分。

但在另一条更偏统计学习的路线里 —— 也就是 Causal Tree / CausalForest—— 研究者更关心的问题是：怎样让 treatment effect的估计误差更小，而且这个差异是稳定可信的。这就引出了下面两个理论视角：CMSE 和 SFT。

CMSE（Causal Mean Squared Error）

理论上，我们希望最小化因果效应估计的误差：

\[\text{CMSE} = E\left[(\tau(X) - \hat{\tau}(X))^2\right]\]

其中 $\tau(X)$ 是真实的CATE，$\hat{\tau}(X)$是模型估计值。

但问题是：真实的 $\tau$无法观测，所以 CMSE无法直接计算。它更像是一个理论目标，告诉我们 “理想情况下希望优化什么”，而实际算法必须用可计算的proxy 去近似它。

一个常见的近似思路是：如果某个切分能让左右子节点的真实 treatmenteffect 明显不同，那么每个叶子内部的 treatment effect往往会更一致。叶子内部越一致，用同一个 $\hat{\tau}$去代表这个叶子的样本，误差通常就越小。

也就是说，CMSE 背后的直觉不是 “直接算误差”，而是：

尽量把 treatment effect不同的人分到不同叶子里，让每个叶子内部更同质。

这可以用一个熟悉的方差分解来理解：

\[\text {总方差} = \text {叶间方差} + \text {叶内方差}\]

在总方差给定时，如果切分让叶间差异变大，那么叶内差异通常会变小。叶内差异小，就意味着每个叶子里的真实$\tau$更一致，从而更有利于降低估计误差。

当然，这里要特别小心：上面这套逻辑是理论动机和近似直觉，不是说任何分裂准则都和CMSE 严格等价。真正落到算法上，还需要选择一个可计算的切分目标。

SFT（Signal-to-Noise Ratio / 稳定性考虑）

仅仅看到 “左右子节点的效应差异大” 还不够，因为这个差异可能只是噪声。于是另一个自然问题是：

这个差异到底是异质性信号，还是小样本波动造成的假象？

这就是 SFT /信噪比视角想回答的问题：不仅要看差异大不大，还要看这个差异稳不稳。

如果一个切分让左边 uplift = 30%，右边 uplift = 5%，但左边只有 10个样本，那这个差异很可能并不可靠；如果左右都有足够样本，而且差异稳定复现，那么它更可能是真实异质性。

所以，CMSE 更强调 “估计误差要小”，SFT更强调 “差异要稳定可信”。两者共同指向的是同一个目标：找到既有异质性、又能稳定估计的切分。

从统一目标到两类分裂准则

到这里可以把前后内容统一起来：不管是 Uplift Tree，还是 Causal Tree /Causal Forest，本质上都在做同一件事 —— 寻找 treatment effect异质性最大的切分。只是它们给 “切分质量” 打分的方式不同。

1. Uplift Tree：从分布差异出发

Uplift Tree更常见的做法，是先比较一个节点内实验组与对照组的结果分布差异，比如用 KL/ Euclidean / Chi-square 距离打分。

在二分类场景下，如果用欧式距离作为节点分数，那么：

\[\phi(node)=D_E(node)=2\hat{\tau}_{node}^2\]

再把它写成 split gain：

\[\text{Gain}(s)=\frac{n_L}{n}\phi(L)+\frac{n_R}{n}\phi(R)-\phi(P)\]

可以推出：

\[\text{Gain}(s) \propto \frac{n_L n_R}{n^2}(\hat{\tau}_L-\hat{\tau}_R)^2\]

这说明在二分类 + 欧式距离设定下，Uplift Tree虽然表面上是在看 “节点里的分布差异”，但它最终偏好的，依然是左右子节点treatment effect 差异大的切分。

2. Causal Tree / CausalForest：从效应差异与估计误差出发

Causal Tree / Causal Forest则更直接一些：它通常不先绕到分布距离，而是直接围绕 treatment effect点估计 $\hat{\tau}$及其稳定性来构造切分准则。

最直接的一类准则是：选择让左右子节点 treatment effect差异最大的切分：

\[\max_{j,s} \left( \hat{\tau}^{left}(j,s) - \hat{\tau}^{right}(j,s)\right)^2\]

其中，在某一个节点内：

实验组平均结果是 $\bar{Y}^T$
对照组平均结果是 $\bar{Y}^C$
估计的 treatment effect 是 $\hat{\tau} =\bar{Y}^T - \bar{Y}^C$

这个准则的直觉很直接：如果一个切分让左右两边的 uplift明显不一样（比如左边 15%，右边 -5%），那它就捕捉到了异质性。

在此基础上，还可以进一步把稳定性也纳入准则，例如使用类似 t-statistic的形式：

\[\frac{\left(\hat{\tau}^{left} -\hat{\tau}^{right}\right)^2}{\widehat{Var}(\hat{\tau}^{left}) +\widehat{Var}(\hat{\tau}^{right})}\]

这里分子是效应差异的平方，分母是估计方差之和。它在问的是：

左右 uplift差这么多，到底是因为真的有异质性，还是因为样本太少、噪声太大？

这类方差调整后的准则，正好对应了前面提到的 SFT / 稳定性视角。

关键技巧：Honest Estimation

无论使用哪一类基于 $\hat{\tau}$的切分准则，都会遇到一个共同问题：分裂时用的是估计值 $\hat{\tau}$，不是真实的 $\tau$。如果同一批数据既用来找切分、又用来估叶子效应，模型就很容易偏好那些 “在这批数据上碰巧差异大” 的切分。

这就是为什么 Causal Tree / Causal Forest 通常会配合 HonestEstimation：

样本	用途
样本 A	决定怎么切（找异质性结构）
样本 B	估计切完后的 treatment effect

把切分和估计分开后，样本 B负责做 “公正” 的叶子效应估计，可以显著降低过拟合偏误。更严格地说，这也是后续渐近正态性和置信区间推断的重要基础。

Uplift Tree 与 Causal Tree /Forest：到底是什么关系？

现在可以把前面几段放到一张图里理解：

共同目标：都在寻找 treatment effect异质性最大的切分
Uplift Tree 的角度：从实验组 /对照组的结果分布差异出发
Causal Tree / Forest 的角度：从 treatment effect点估计及其估计误差出发

它们并不是完全相同的一套准则，只是服务于同一个目标的两条方法路线。

两者的联系在二分类问题里尤其明显：

\[P^T(1) - P^C(1) = \hat{\tau}\]

所以在二分类场景下，“分布差异” 和 “uplift差异” 本质上是在衡量同一件事；区别主要在于：前者更强调整个结果分布，后者更强调 treatmenteffect 点估计及其稳定性。

选择哪种方法？取决于业务需求：

需要考虑整个结果分布的变化 → Uplift Tree 的距离度量更全面
需要简洁的 uplift 点估计和置信区间 → Causal Tree / Forest更直接
样本量有限、需要稳定性 → 带方差调整的 Causal Tree / Forest准则更稳健

4. 小结：三种树的分裂目标对比

方法	分裂目标	通俗一句话
普通决策树	最小化预测误差或分类不纯度	把结果相似的人分到一起
Uplift Tree	最大化实验组 vs 对照组的分布差异	把 treatment effect 不同的人区分开
Causal Tree / Forest	最大化 treatment effect 异质性，同时控制估计误差	把 treatment effect不一样的人分到一起，还要确信这个差异是靠谱的

更通俗地说，普通树学的是 “谁更像”，Uplift Tree学的是 “谁更会被改变”，Causal Tree / Forest学的是 “谁更会被改变，而且这个判断在统计上更站得住”。

在 uplift 场景中，相较于 uplift tree，Causal Forest更常用一些，但两者各有适用场景

Causal Forest 的优势是

工程稳定性更强：单棵 Uplift Tree容易过拟合、不稳定，Causal Forest 是集成方法，泛化能力更好
理论支撑更完善：Honest estimation可以给出置信区间，渐近正态性支持统计推断
能捕捉更复杂的异质性：特征交互、非线性关系处理更强，适合特征多、关系复杂的业务场景

Uplift Tree 的优势是

需要规则解释：单棵树可以输出清晰的分裂规则，方便运营理解和执行，适合做人群切分洞察
快速原型验证：实现简单、训练快，可以快速判断 uplift信号是否存在
规则引擎落地：有些业务系统需要 if-else 规则，UpliftTree 可以直接转成规则

实际工程中的常见选择：

阶段	常用方法	原因
快速验证 uplift 是否存在	S-Learner / Uplift Tree	简单、快
追求 CATE 精度	X-Learner / Causal Forest	更鲁棒、理论支撑强
需要规则输出	Uplift Tree	解释性好
生产环境部署	Causal Forest / Meta-Learner	稳定性优先

一句话总结：Causal Forest更适合作为” 主力模型”，因为它稳定、理论完善、工业界验证多；UpliftTree更适合作为” 辅助工具”，用来做规则洞察、人群切分、快速原型。

方法选择

如果把上面讨论的几类方法放在一起对比，大致可以这样理解：

方法	适用场景	优点	缺点
S-Learner	快速验证、小数据	实现简单、样本利用率高	弱 treatment 时容易失效
T-Learner	样本均衡、效应较明显	结构直观	样本效率低、误差叠加
X-Learner	样本不平衡、追求精度	更鲁棒、效果通常更好	链路复杂
Uplift Tree	需要规则解释、人群切分	可解释性好	稳定性一般
Causal Forest	非线性强、希望估计更稳	理论支撑更强、能捕捉复杂效应	计算成本高

工程里没有银弹。很多时候，最好的方式不是一开始就追求最复杂模型，而是：

用简单 baseline 快速验证 uplift 是否真的存在
再逐步切到更强的 effect learner
最后把重心放在策略使用方式，而不是只盯着离线分数

评估指标

Uplift 的评估方式和普通分类或回归不同。原因很简单：真实的 ITE不可观测 —— 我们永远看不到同一个用户在 “接受干预” 和 “未接受干预” 两个世界里分别会怎样。

因此，uplift 模型通常重点评估两件事：

排序能力：能否把 treatment effect更高、更值得干预的人排在前面
校准能力：模型预测的 uplift数值，是否与人群中实际估计出的 group-level treatment effect 一致

AUUC 和 Qini 主要衡量第一件事。它们与分类任务中的 AUC有相似的排序直觉，但不是同一个数学结构；评估时也必须使用独立测试集或out-of-fold 预测，否则训练集上的排序结果会过于乐观。

需要特别说明的是，业界和不同工具库对 “uplift curve”“gain curve”“AUUC”的命名并不完全统一。为避免把不同纵轴下的面积混为一谈，本文采用以下口径：

$U(p)$：前 $p$ 比例人群的平均uplift
$G(p)=pU(p)$：按全体人群归一化后的累计增益
AUUC：累计增益曲线 $G(p)$ 下的有符号面积
Qini 系数：累计增益曲线超过随机基线 $p\cdot ATE$ 的有符号面积

有些工具还会用 “完美排序曲线” 的面积进一步归一化。因此，实际比较指标前，必须确认纵轴、随机基线以及是否做过归一化。

平均 uplift 曲线

想象有 1000 个用户，按模型预测的 uplift 从高到低排好队：

先在独立 RCT 测试集中取前 10% 的用户：如果该部分人群内 treatment 和control 样本量都达到最低要求，就用两组 outcome mean 之差估计该前缀人群的average uplift
再依次扩展到前 20%、30% 等分位点，用同样的方法重新估计这些人的average uplift
依此类推，一直扩展到 100%

average uplift 的计算方法，就是对排序后的前 $k$ 个样本，treatment 和 control 的 outcomemean 之差。如下所示

\[\hat U(p_k)=\frac{1}{N_k^T}\sum_{i\leq k,\,T_i=1}Y_i-\frac{1}{N_k^C}\sum_{i\leq k,\,T_i=0}Y_i,\qquad p_k=\frac{k}{N}\]

其中，$T_i\in\{0,1\}$ 表示treatment assignment，$Y_i$是观测结果，$N_k^T$ 和 $N_k^C$ 分别是前缀中的 treatment、control样本数。

该估计要求前缀内同时存在 treatment 和 control 样本，即 $N_k^T>0$ 且 $N_k^C>0$。随机化只保证两组在重复抽样的期望上可比，并不保证任意有限前缀都具有足够的empirical overlap；样本不足时应扩大前缀、合并分桶或跳过该覆盖点。

这个过程实际上做的事情是估计 “如果策略只覆盖这部分人，预期会获得多少uplift”。如果把 “覆盖比例 $p$→ 该前缀人群的 average uplift” 画出来，就得到平均 uplift 曲线$U(p)$。如果模型排序有效，曲线前段通常高于全体ATE；覆盖到 100% 时，理论曲线满足：

\[U(1)=ATE\]

如果模型排序完全随机，任意前缀的人群构成在期望上都与总体一致，因此：

\[\mathbb E[U_{\mathrm{rand}}(p)]=ATE\]

所以平均 uplift 曲线的随机基线是一条高度为 ATE的水平线。模型排序有效时，曲线前段通常高于这条基线。

当模型排序准确时，高 uplift 的用户会排在前面，所以平均 uplift曲线往往是一条从左上到右下的逐步降低的曲线。但有限样本曲线会受到随机噪声影响，不一定单调下降；只有在总体层面且排序与真实CATE 完全一致时，才能保证这种单调性。

这个过程常常遇到的一个问题是：前 $k$ 个用户彼此是否是同质？

如果把 “同质” 定义为两个用户在模型使用的特征上完全一致，那么可以写成$X_i=X_j$。这个条件与 CATE的定义直接相关：

\[\tau(x)=E[Y(1)-Y(0)\mid X=x]\]

AUUC 评估的不是某一个固定 $x$ 上的CATE，而是模型选出的整个前缀人群的 group-level treatment effect。设前$p$ 比例人群为：

\[S_p=\mathbb{1}\{s(X_{\mathrm{pre}})\geq c_p\}\]

那么平均 uplift 曲线上的点对应：

\[\begin{aligned}U(p)&=E[Y(1)-Y(0)\mid S_p=1] \\&=E[\tau(X)\mid S_p=1]\end{aligned}\]

这个量也可以理解为该前缀人群的 Group Average TreatmentEffect（GATE）。前缀内部可以包含多种 $X$ 和不同的 CATE，$U(p)$ 是这些 effect按该人群构成加权后的平均值。只要线上策略确实准备覆盖这整个前缀，$U(p)$就有明确的业务含义：它表示每个被覆盖用户的期望平均增量，而 $NpU(p)$ 表示 $N$ 个候选用户中覆盖前 $p$ 比例时的期望总增量。

例如，某个前缀人群中有 60% 的 A 类用户，其 CATE 为 20%；另有 40% 的 B类用户，其 CATE 为 5%。这批用户并不同质，但如果策略会同时覆盖 A、B两类，那么该策略面对的人群 GATE 就是：

\[U(p)=60\%\times20\%+40\%\times5\%=14\%\]

因此，计算前缀的 average uplift，不要求前 $k$ 个用户彼此同质；真正需要的是前缀内的treatment / control 来自同一个目标人群。换句话说，不要求每个 treatment用户都能找到一个特征完全相同的 control用户，而要求两组的特征分布在期望上相同：

\[X\mid(T=1,S_p=1)\ \overset{d}{=}\ X\mid(T=0,S_p=1)\]

实现这一点需要模型分数只依赖 pre-treatment features，并且treatment在评估样本中保持随机分配，分配概率在该前缀内恒定。理想 RCT在总体层面满足：

\[T\perp\left(Y(1),Y(0)\right)\mid S_p=1\]

在 consistency 和 SUTVA 等前文假设成立时，由此可以得到：

\[E[Y\mid T=1,S_p=1]-E[Y\mid T=0,S_p=1]=U(p)\]

累计增益曲线与 AUUC

如果前 $p$ 比例人群的平均 uplift为 $U(p)$，那么只干预这部分人时，按全体人群归一化后的累计增益为：

\[G(p)=p\cdot U(p)\]

若总体共有 $N$人，对应的期望绝对总增量是 $NpU(p)$。这里使用 $G(p)$而不是绝对总量，是为了避免指标随评估集样本数线性缩放。

例如，总体有 1000 人，前 10% 人群的 average uplift 为 20%，那么：

\[G(10\%)=10\%\times20\%=2\%\]

这表示相对于全部 1000 人，策略带来了 2 个百分点的归一化累计增量。若$Y$是二值响应指标，对应的期望绝对增量为 $1000\times2\%=20$ 个响应。

累计增益曲线从 $G(0)=0$开始，并在全量覆盖时到达：

\[G(1)=ATE\]

这是总体层面的理论终点；在有限测试集上，经验曲线的终点是 $\hat G(1)=\widehat{ATE}$。

随机排序下，每个前缀的平均 uplift 期望都等于 $ATE$，所以随机累计增益基线是一条斜线：

\[G_{rand}(p)=p\cdot ATE\]

累计增益曲线的形态取决于继续扩大覆盖时，新纳入人群的 marginaltreatment effect。若用 $\tau(p)$表示排序分位点 $p$ 附近人群的marginal treatment effect，则：

\[G'(p)=\tau(p)\]

因此，$\tau(p)>0$时曲线继续上升，$\tau(p)=0$时曲线进入平台，$\tau(p)<0$时曲线开始下降。排序较好的模型，其曲线通常从原点快速上升，并在大部分区间高于随机基线；如果尾部存在negative uplift，曲线可能在某个覆盖率达到峰值后下降，最终在 $p=1$ 时与随机基线汇合。

本文将累计增益曲线下的有符号面积定义为 AUUC：

\[AUUC=\int_0^1G(p)\,dp=\int_0^1pU(p)\,dp\]

实际计算时，先由上一节的前缀 average uplift 得到：

\[\hat G(p_m)=p_m\hat U(p_m)\]

然后在一组分位点 $0=p_0 上估计\(\hatG(p_m)$，再用梯形法近似积分：

\[\widehat{AUUC}=\sum_{m=1}^{M}\frac{p_m-p_{m-1}}{2}\left(\hat G(p_m)+\hat G(p_{m-1})\right)\]

从总体层面看，设 $\tau(q)$表示预测排序分位点 $q$ 附近人群的marginal treatment effect，而不是某个用户可观测的 ITE，则：

\[G(p)=\int_0^p\tau(q)dq\]

交换积分次序可以得到：

\[AUUC=\int_0^1\int_0^p\tau(q)dq\,dp=\int_0^1(1-q)\tau(q)dq\]

权重 $1-q$随排序位置递减，因此越靠前的人群对 AUUC 贡献越大。由此可见，把 marginaltreatment effect 更高的人群排在前面会得到更高的AUUC。需要注意，这个结论描述的是不可直接观测的总体目标；有限测试集上的treatment / control outcome mean 之差只是对它的有噪声估计。

Qini 系数

AUUC 包含了 treatment整体平均效果的贡献。即使排序完全随机，累计增益曲线下仍有面积：

\[\mathbb E[AUUC_{rand}]=\int_0^1p\cdot ATE\,dp=\frac{ATE}{2}\]

Qini将随机基线扣除，回答的是：与随机投放相比，模型排序额外带来了多少增益？

Qini 曲线定义为：

\[Q(p)=G(p)-G_{rand}(p)=p\left(U(p)-ATE\right)\]

Qini 系数就是该曲线与零轴之间的有符号面积：

\[\begin{aligned}Qini&=\int_0^1Q(p)\,dp \\&=\int_0^1p\left(U(p)-ATE\right)dp \\&=AUUC-\frac{ATE}{2}\end{aligned}\]

随机排序时，Qini 的期望为 0。Qini为正，说明模型总体上优于随机排序；Qini为负，则说明模型排序整体比随机策略更差。曲线在不同覆盖区间可能上下穿越随机基线，因此不能只看某一个分位点来判断整体Qini 的正负。

平均 uplift 曲线与累计增益曲线可以通过 $G(p)=pU(p)$相互转换，因此包含相同的点态信息；但二者的面积并不相等：

\[\int_0^1U(p)dp\neq\int_0^1pU(p)dp\]

应该怎么看这些指标？

可以用一张图来总结这两条曲线和两个指标

曲线或指标	定义	主要回答的问题
平均 uplift 曲线	$U(p)$	覆盖到某个比例时，这批人的 average uplift 是多少？
累计增益曲线	$G(p)=pU(p)$	覆盖到某个比例时，累计获得了多少增量？
AUUC	$\int_0^1G(p)dp$	在相同评估人群和 treatment定义下，模型跨覆盖阈值的整体排序表现如何？
Qini	$\int_0^1(G(p)-pATE)dp$	模型排序相对随机策略多贡献了多少？

AUUC 和 Qini是跨阈值的排序汇总指标，并不等同于某一个实际投放策略的业务价值。若线上只能覆盖前$p^*$比例人群，真正需要关注的是该点的 $G(p^*)$，再结合 treatment成本计算净收益。

进行模型或实验间比较时，还需要保持以下口径一致：

标签及量纲：7 日付费率和 7 日 GMV 的 uplift不在同一尺度上
目标人群分布：不同地区、时间或准入条件下的异质性结构可能不同
业务定义：是否计入退款、是否过滤异常订单等都会改变结果
曲线定义与归一化方式：必须确认纵轴是平均uplift、按总体归一化的累计增益，还是绝对增量，并确认是否除以完美曲线面积
评估不确定性：样本量不会改变归一化指标的理论目标，但会改变估计方差和置信区间

最后还要区分实验比例与因果识别问题。在 treatment随机分配且概率恒定时，即使实验组和对照组不是 1:1，前缀均值差仍可估计treatment effect，但 9:1之类的严重不均衡会让少数组样本不足、曲线方差变大。对于 propensity随特征变化的实验或观测数据，简单均值差一般不再可靠，应使用 IPW、Hájek 或doubly robust 估计进行校正；同时要注意，极端 propensity产生的大权重反而可能放大方差，需要配合权重稳定化、截断或 overlaprestriction。

实际优化落地案例

前面的内容主要讨论理论与方法。接下来把视角从模型本身拉回到更通用的策略优化框架。

无论是电商发券、广告激励、直播调控，还是推荐系统里的流量分发，本质上都在回答同一个问题：对这个用户施加某种干预，到底值不值得？

这类问题都可以抽象成一个统一的 gain-cost 权衡框架：

Gain：干预后希望提升的核心业务价值
Cost：干预带来的资源消耗、副作用或局部业务损失

方法本身并不依赖某个垂直场景，真正变化的只是不同业务下 gain 指标和cost 指标的定义。

场景	Treatment	Gain 指标	Cost 指标
电商营销	发券、加补贴、提高触达频次	下单率、GMV、7 日 LT	券成本、补贴消耗、毛利损失
广告投放	提高出价、增加曝光、发放激励	点击、转化、广告收入	流量占用、补贴成本、体验损耗
内容 / 直播分发	增减某类内容曝光、调整流量占比	留存、会话、时长、长期价值	子业务收入下滑、生态指标波动

如果只盯着单一 gain，很容易把策略做偏；只有把 gain 和 cost同时纳入建模与决策，策略才真正有上线意义。

整体链路

一个完整的 uplift 策略链路，通常可以抽象为：

通过随机实验构造 treatment / control 数据
训练 uplift 模型，估计用户的增量收益与增量成本
在预算或约束条件下，把模型分转换成可执行决策
在线持续监控并动态更新策略

数据构造

RCT / Switchback 实验设计

实验形式并不唯一，常见的设计包括：

用户级随机实验：适合电商发券、广告激励等用户独立干预场景
Switchback Experiment：适合供给、流量、时段级干预场景
分桶灰度实验：适合线上策略逐步放量验证

共同目标只有一个：让 treatment assignment尽量随机，从而降低选择偏差，提升 uplift 估计的可信度。

做这类实验时，至少有三点要特别关注：

随机化是否真的均匀覆盖关键人群
实验期间是否有外部流量策略或业务活动干扰
样本量是否足够支撑异质性效应学习

很多 uplift项目不是死在模型，而是死在实验设计不够干净

Feature 与 Label 设计

在一个通用的 uplift项目里，特征通常会覆盖用户、行为和上下文等多类信息，例如：

特征类别	示例特征	业务含义
基础用户特征	年龄、性别、注册时长	用户基本属性
历史交易特征	下单次数、客单价、复购间隔	商业价值与购买习惯
广告交互特征	曝光、点击、转化、激励领取	广告敏感度
内容消费特征	时长、完播率、互动次数	内容偏好与注意力分布
价格敏感特征	价格带偏好、折扣使用率	对补贴和优惠的敏感程度
设备与环境特征	机型、网络、地域、时段	外部约束与场景差异
流量上下文特征	入口、版位、资源位竞争情况	当前供给环境
用户画像与分层	兴趣标签、价值层级、风险标签	用户分类
社交关系特征	关注、粉丝、互关、分享关系	社交传播潜力
趋势特征	7d / 30d 行为差值、比值、斜率	状态变化

这里有一个很重要的实践经验：Uplift 特征工程的重点，不只是提升responseprediction，而是尽量暴露 “谁对干预更敏感” 的异质性。因此，能体现趋势、状态切换、消费结构差异的特征，往往比静态画像更重要

在这个通用框架下，一般会建议把 label 拆成两类。

1、Gain Label

表示 “施加干预后，业务核心目标获得的增量收益”。

例如：

电商：7 日下单率、GMV、复购、长期价值
广告：点击率、转化率、广告收入、广告主 ROI
内容 / 直播：留存、有效会话、消费时长、长期活跃价值

2、Cost Label

表示 “施加干预后，需要付出的资源消耗或副作用”。

例如：

电商：优惠券成本、补贴消耗、毛利损失
广告：流量占用、补贴成本、用户体验下降
内容 / 直播：某子业务收入下降、供给生态波动、时长迁移损失

这一点很关键：很多策略只预测 gain，不预测cost，最后上线时容易出现 “主指标提升了，但业务副作用太大” 的问题。把 gain和 cost 拆开建模，本质上是在为后续约束优化做准备。

3、多 Label 场景

当我们优化目标有多个时，Label 往往也会有多个（比如说 LT 优化阶段 costlabel，可能会同时影响时长和营收）。这个时候时候需要考虑如何将多个 label合并成一个，方便模型的学习和后续规划问题的求解。常见做法是直接使用原始label，并通过人工权重去对齐不同指标的量纲，如下所示：

\[y = w_1 y_1 + w_2 y_2 + w_3 y_3\]

但这种方式有几个明显问题：

超参数很难调
极端值影响大
一旦分布漂移，稳定性差

实际中一种更常用的方法是百分位归一化方案,也就是用样本在训练集中的相对位置，替代原始值本身

\[y = w_1 * \text{percentile\_rank}(y_1) + w_2*\text{percentile\_rank}(y_2) + w_3 * \text{percentile\_rank}(y_3)\]

这么做的优点很明显：

通过 $\text{percentile\_rank}$函数将原始量纲不一致的 label，都固定在特定范围内如[0, 1]，便于模型学习
不同的目标的兑换关系更可控，可通过让 $w$的值保持一致，来让各目标的权重都保持一致，也可人工拍一个兑换关系，并且不容易收到不同目标的预估漂移的影响（如目标A 统一高估 10 倍）
对极端值更鲁棒
更贴近后续排序型决策的使用方式

这也是一个很典型的工程取舍：真实业务中，很多时候不需要模型把绝对收益估得极准，而是更需要它把相对优先级排对。

模型选择与评估

如果要在多类业务场景里选择一个相对稳妥的异质性效应学习器，CausalForest往往是一个不错的起点，具体原因上面做模型横向对比分析时提过了，这里就不在赘述

离线评估指标这部分在前面也提到了。实际中，更值得关注的是训练集与测试集上的AUUC、Qini 是否一致，以及不同分桶上的 uplift 排序是否稳定。

这里有两个经常出现、但容易被误读的现象：

1、稀疏 cost label 的 AUUC 绝对值可能很小

如果某个 cost指标本身零值很多、分布非常稀疏，那么即使模型把排序做对了，AUUC的绝对值也未必会特别大。这并不一定意味着模型无效，更可能只是标签本身的信息密度较低。

2、某些 cost 相关指标的 AUUC 可能为负

这通常出现在 “抑制型干预” 里，比如减少某类曝光、压缩某类补贴、降低某类流量占比。此时treatment 的目标，本来就是牺牲局部指标去换取整体收益，所以 cost维度出现负向 uplift，往往反而说明方向符合预期。

因此，评估 uplift 模型时，不应该孤立地看某一个 gain 或 cost指标，而应该结合策略目标去理解其方向性和 trade-off。

线上决策

至此我们训练了两个模型，用来预估模型施加 treatment 前后的 $\Delta \text{gain}$ 和 $\Delta \text{cost}$

但真正有业务价值的，不是简单给用户打一列 uplift 分，而是要在 Gain 与Cost 之间做最优选择

最优化问题定义

首先我们可以很自然地定义如下的约束优化问题

设有 $n$ 个用户，对用户 $i$ 干预后：

业务收益预估值为 $\text{gain}_i$
业务损失预估值为 $\text{cost}_i$

定义决策变量：

\[x_i \in \{0, 1\}\]

其中 $x_i = 1$表示对用户施加干预。

如果预算或业务损失约束为 $C$，优化目标可写成：

\[\begin{aligned}\max_{x_i} \quad & \sum_{i=1}^{n} x_i \cdot \text{gain}_i \\\text{s.t.} \quad & \sum_{i=1}^{n} x_i \cdot \text{cost}_i \le C \\& x_i \in \{0, 1\}\end{aligned}\]

这其实就是 “在有限成本下，选出最值得干预的人”。

直接求解这个问题，可以构造如下拉格朗日函数：

\[L(x, \lambda) = \sum_{i=1}^n x_i (\text{gain}_i - \lambda \cdot\text{cost}_i) + \lambda C\]

为了最大化 $L$，对于每一个独立的$i$，我们的决策逻辑是：

如果 $(\text{gain}_i - \lambda \cdot\text{cost}_i) > 0$，即 $\frac{\text{gain}_i}{\text{cost}_i} >\lambda$，则取 $x_i = 1$
如果 $\frac{\text{gain}_i}{\text{cost}_i}< \lambda$，则取 $x_i =0$

这里的 $\lambda$可以理解为成本的影子价格。

这个结论很重要，因为它说明：在给定成本约束下，按单位成本收益（ROI）排序，本身是有优化基础的。

近似求解：贪心策略

直接套拉格朗日求解，工程上有两个不便：

需要一个明确的预算 $C$，但在 cost由多指标融合并经归一化后，$C$已经丧失了物理含义（不像发券这类场景预算是显式的金额），只能凭分布拍一个数
求解依赖 gain 和 cost 的绝对值估准；而 uplift模型的输出经过 label归一化、样本选择偏差等处理后，绝对值常常存在系统性偏移。$\lambda$一旦定死，模型若高估收益就会超支，若低估则预算结余

工程上更常用的是贪心策略：

计算每个用户的 $\text{ROI}_i =\dfrac{\text{gain}_i}{\text{cost}_i}$
按 ROI 从高到低排序
从前往后累加 cost，直到达到预算 $C$ 或人数比例阈值

贪心和拉格朗日在解上是等价的：把人按 ROI从高到低取，最后一个被选中用户的 ROI 就是隐式的最优影子价格 $\lambda^\star$；前面所有 $\text{ROI}_i > \lambda^\star$的用户都满足拉格朗日的最优性条件 $\text{gain}_i - \lambda^\star\,\text{cost}_i >0$。换句话说，贪心是在用排序 + 累加，隐式地做对偶上升找到$\lambda^\star$，省掉了显式求解非线性方程。

贪心相较于显式拉格朗日求解的两个工程优势：

1. 对预估偏差更鲁棒

显式拉格朗日要求 gain / cost 的绝对值估得准，否则固定 $\lambda$会导致超支或预算结余；而贪心只要相对排序对就行 —— 按人数quantile或动态预算池截断，无论分数怎么漂移，选出的都是当前最值得干预的那批。

2. 线上计算更高效

贪心退化为” 打分 + 排序 +阈值对比”，可以离线 / 近线预计算，比在线解非线性方程快得多。

平滑Treatment：从硬阈值到软强度

无论用拉格朗日还是贪心，前面得到的都是硬阈值决策：$\text{ROI} > \lambda^\star$全干预，否则完全不干预。这种 0 / 1决策在很多业务里是次优的，原因有两点：

1. 失去探索空间

如果 treatment 是” 不出某体裁” 这种强干预，对高 ROI用户完全不出会让系统永远观察不到他们对该体裁的真实反馈，也就是永远丧失了对这部分用户的探索，这对业务提高渗透的目标来看是基本不太能接受的

2. 整数解会浪费预算

举个例子：预算 $C =2.5$，两个用户：

用户 A：$\text{gain}=10$，$\text{cost}=2$，$\text{ROI}=5$
用户 B：$\text{gain}=8$，$\text{cost}=2$，$\text{ROI}=4$

硬阈值（贪心或拉格朗日都一样）：先选 A（cost = 2 ≤ 2.5），再考虑 B时累计 cost 会变成 4 > 2.5，只能舍弃 B。最终 gain =10，剩余 0.5 预算被浪费。

如果允许把 treatment 强度分摊（连续的 $x_i\in [0,1]$，理解为概率或强度比例），把 1.5 的 cost 分给 A（强度75%）、1 的 cost 分给 B（强度 50%），假设 gain 与 cost 等比例缩放，则总gain = $10 \times 0.75 + 8 \times 0.5 = 11.5> 10$。

LP 松弛的最优解形式

LP 松弛（Linear ProgrammingRelaxation）是组合优化里最经典的近似求解套路之一 —— 把 $x_i \in \{0,1\}$ 这种整数约束放松成 $x_i \in [0,1]$，原问题变成线性规划，可以用KKT / 单纯形法精确求解。

我们当前面临的问题是一个背包问题，而连续背包问题（fractionalknapsack）的最优解就是按 ROI排序的贪心解，这是个有严格证明的经典结论；0 / 1 背包的 LP松弛最优解最多只有一个分数变量，和整数解的最优值差距有界

通过把整数约束 $x_i \in \{0,1\}$放松为连续 $x_i \in [0,1]$，对偶变量$\lambda \ge 0$ 对应预算约束。其 KKT条件给出最优解如下：

\[x_i^\star =\begin{cases}1, & \text{ROI}_i > \lambda^\star \\\in [0,1], & \text{ROI}_i = \lambda^\star \\0, & \text{ROI}_i < \lambda^\star\end{cases}\]

也就是 ROI 高于影子价格 $\lambda^\star$的全开、低于的全关。这本身仍是阶跃函数，但提供了一个关键性质：最优treatment 强度是 ROI 的单调不减函数。

LP 松弛在 uplift 这类预算约束问题里特别合适的几个原因：

解的结构清晰：上面的阶跃形式直接对应业务里” 按 ROI排序后取 top-K” 的朴素直觉，模型分能直接转成可执行的策略
天然支持平滑：连续 $x_i$本身可以解释成” 概率/强度”，工程上正好对应平滑treatment（发券概率、推荐分加权、排序惩罚力度等），不像整数解那样需要额外做” 舍入到0/1”
和贪心的等价关系：连续背包的 LP 解就是 ROI排序贪心解，所以前一节的贪心策略本身就是 LP松弛在背包结构下的精确解，不需要额外求解器

LP 最优解的固有性质：单调性

上面 KKT 形式已经隐含了”$x_i^\star$ 关于 $\text{ROI}_i$单调不减”，但这个性质并不依赖任何函数形式 —— 它是任何” 预算约束下连续分配” 问题最优解的固有性质，可以用exchange argument（交换论证）严格证明。

考虑两个用户 $i, j$（$\text{cost}_i, \text{cost}_j >0$），假设 $\text{ROI}_i >\text{ROI}_j$，但反证地假定最优解里 $x_i^\star 。我们做一个微小预算转移：从 \(j$ 收回 $\varepsilon$ 单位 cost、转给 $i$：

$x_j$ 减小 $\dfrac{\varepsilon}{\text{cost}_j}$，释放出$\varepsilon$ 单位 cost
$x_i$ 增大 $\dfrac{\varepsilon}{\text{cost}_i}$，消耗$\varepsilon$ 单位 cost

总 cost 不变，预算约束仍满足。目标函数的变化是：

\[\Delta \text{Obj} = \frac{\varepsilon}{\text{cost}_i}\cdot\text{gain}_i- \frac{\varepsilon}{\text{cost}_j}\cdot\text{gain}_j = \varepsilon\cdot (\text{ROI}_i - \text{ROI}_j) > 0\]

也就是说我们能严格提高目标值，与” 原方案最优” 矛盾。所以最优解必然有$x_i^\star \ge x_j^\star$。

这个 exchange argument不假设任何函数形式，得到的结论是个客观事实：只要预算可以连续分配、ROI定义良好（cost > 0），最优分配就一定按 ROI单调不减。连续背包、网络流分配、广告竞价都是同一个机制。

映射函数选择

KKT 的阶跃形式不能直接落地（不可导、无探索），工程上要找一个函数$f(\text{ROI})$来近似它，这个函数必须满足：

单调不减 —— 这是上面 exchange argument强制要求的，否则就不是 LP 最优解的合法近似
平滑可导 —— 方便端到端训练、梯度优化
值域 $[0,1]$—— 对应概率 / 强度的语义
在 $\text{ROI} =\lambda^\star$ 附近过渡 —— 保留阶跃解的形态

满足这些条件的函数族很多：

函数族	形式	备注
Sigmoid	$\sigma\!\big(\alpha(\text{ROI} -\lambda^\star)\big)$	最常见；$\alpha$ 控制陡峭度
Hardsigmoid / 分段线性	$\text{clip}(\alpha(\text{ROI} -\lambda^\star) + 0.5,\,0,\,1)$	计算更便宜
任意单调分布 CDF	$F(\text{ROI})$	概率解释更自然（如截断正态）
Softplus 复合	$1 -e^{-\text{softplus}(\alpha(\text{ROI}-\lambda^\star))}$	长尾控制更灵活

工程上选 sigmoid 主要是因为形式简单 + 处处可导 +业务里好调参，并不是它在数学上” 更优”。换成其他单调平滑函数，结论同样成立。

最后我们可以看到，线上生效的往往是 “ROI 越高 → 惩罚越大” 的逻辑。

这在直觉上也讲得通：预算约束下” 边际收益高的人多分一点资源”——ROI高意味着这个干预对该用户性价比高，自然该多分干预强度。这是约束优化下的资源分配定律，和拍卖里高出价者得到更多资源是同一回事。

因此，平滑映射在线上的优势往往是

1、保留探索空间，缓解反馈闭环
2、充分利用预算（避免整数约束的舍弃浪费）
3、不同用户分配不同强度，干预动作更精细

自适应分布

策略上线后，数据分布很可能发生变化。

常见问题包括：

1、Uplift ROI 分布漂移

解决思路是对分数再做归一化，把它映射到稳定区间[a, b]，从而让阈值与分位更可控。

2、业务指标长期右移或左移

比如客单价、转化价值、时长、广告出价等指标随着业务阶段变化持续右移或左移，这时模型分可能没问题，但决策阈值和预算映射会逐渐失真。

所以，uplift 策略上线之后，不能只看模型是否更新，还要持续看：

分数分布是否漂移
人群覆盖率是否异常
gain / cost 比例是否变化
策略副作用是否扩大

反馈闭环陷阱

策略上线后，最容易踩的坑是直接用线上数据回训模型。这是uplift 场景特有的、且比 CTR / CVR 严重得多的问题，值得单独说一下。

线上 uplift策略上线后，干预分配不再随机：高分用户几乎都被干预，低分用户几乎都不干预。这直接破坏了uplift 估计的两个关键前提：

重叠性：$0 < P(T=1\mid X=x) < 1$ → 高分人群几乎全是 $T=1$，低分人群几乎全是 $T=0$，重叠区域消失
无混淆性：$T \perp(Y(1), Y(0)) \mid X$ → treatment分配本身就是模型分的函数，混淆被引入

如果直接拿这批” 被策略选过的” 数据回训，模型会把策略本身的选择偏差当成” 因果效应” 学进去，下一轮分数更极端，干预更集中，偏差进一步放大 —— 经典的反馈闭环。

这个问题其实 CTR、CVR 也有，但是对 uplift 来说比 CTR / CVR 严重得多

维度	CTR / CVR	Uplift
学习目标	$P(Y \mid X)$，单一条件分布	$E[Y(1) - Y(0) \midX]$，需要两个反事实分布
偏差类型	即使有曝光偏差，模型仍能学；表现为方差变大	重叠性破坏后直接不可识别，是 bias 不是variance
信号强度	标签密集、信号强	uplift 是两个数相减，信号本身弱 1-2 个量级
误差累积	单向叠加在 $P(Y \mid X)$ 上	双向叠加在 $\hat{\mu}_1 -\hat{\mu}_0$ 上，且策略漂移会加速放大

直觉上：CTR 模型即使有选择偏差，至少还在学” 这群人会不会点”；uplift模型一旦失去重叠性，学到的就根本不是因果效应了，而是策略选择规则本身。

工程上的常见修正手段有如下几种

方法	思路	代价
保留随机 holdout 桶	线上始终留 5%-10% 流量做随机分配，模型只用这部分回训或校准	牺牲一小部分线上收益，换持续可识别性。工业界最常用
IPW（逆概率加权）	用线上策略的实际分配概率 $\hat{e}(x)$ 加权样本，纠正选择偏差	需要 $\hat{e}(x)$ 远离0 / 1，否则方差爆炸
Doubly Robust	同时用响应模型 + 倾向性得分，一方有偏另一方仍可补救	实现复杂，但鲁棒性最好
周期性全量 RCT	定期暂停策略、做一次全量随机收集	短期业务波动较大，多用于早期或周期校准

实际工程里，holdout随机桶是性价比最高的方案：它既维持了 RCT的可识别性，又不用频繁暂停策略；同时 holdout 桶天然可以用来做模型 A / B对比、Qini 曲线评估、阈值校准等多个用途。

最简单的只需要记住：uplift 模型的训练数据必须保持 treatment分配的随机性，不能直接吃自己策略产出的数据，否则就是在自我强化偏差而不是学因果。

多 Treatment 与连续Treatment

前面讨论的内容主要围绕单一、二值的 treatment展开。但实际业务中经常会遇到更复杂的形式：

多Treatment：存在多种离散干预方式（如不同面额的优惠券、不同的广告创意）
连续Treatment：干预存在强度 / 剂量差异（如折扣力度、补贴金额、曝光频次）

这两类场景在因果识别假设、建模方法和决策求解上都和二值场景有明显差异，下面分开讨论。

共同的因果识别假设

二值 treatment的三个假设（无混淆性、重叠性、SUTVA）需要做对应扩展：

无混淆性：要求对所有 $t$ 成立

\[\{Y(t)\}_{t \in \mathcal{T}} \;\perp\; T\;\big|\; X\]

也就是说，给定 $X$ 之后，treatment分配 $T$与所有可能的潜在结果都独立。这通常要靠多臂 RCT（多treatment）或剂量随机化（连续 treatment）来保证。

重叠性：扩展为对每个 $t$ 都需要观测到样本

多 treatment：$P(T=t \mid X=x) > 0,\quad \forall t \in \{0, 1, \dots, K\}$
连续 treatment：条件密度 $f_{T \mid X}(t\mid x) > 0, \quad \forall t \in \mathcal{T}$

这一条在实际业务里最容易踩坑。比如某种 treatment在线上策略里只发给特定人群，那么 $P(T=t \midX=x)$ 在其他人群里就是 0，模型在这部分人群上无法识别 $\tau(x, t)$。

广义倾向性得分（Generalized Propensity Score,GPS）：是二值倾向性得分 $P(T=1 \midX)$ 的推广

多 treatment：$e_t(x) = P(T=t \midX=x)$，每个 $t$ 一个
连续 treatment：$e(t, x) = f_{T \mid X}(t\mid x)$，是条件密度

GPS 是后续 IPW、DR、加权回归等估计器的基础（Imbens 2000；Hirano &Imbens 2004）。

多 Treatment 场景

当存在多种干预选择时，问题从” 要不要干预” 变成了” 用哪种方式干预”。

问题定义

设有 $K+1$ 种 treatment 取值 $t \in \{0, 1, \dots, K\}$，其中 $t=0$ 表示不干预。每种 treatment对应一个潜在结果 $Y_i(t)$，个体处理效应（相对不干预）为$\tau_i(t) = Y_i(t) - Y_i(0)$。

由于 ITE $\tau_i(t)$不可观测，实际建模目标是 CATE：

\[\tau(x, t) = E[Y(t) - Y(0) \mid X = x],\quad t \in \{1, \dots, K\}\]

最优 treatment 决策定义在 CATE 估计上：

\[\hat{t}^\star(x) = \arg\max_{t \in \{0,1, \dots, K\}} \hat{\tau}(x, t)\]

其中 $\hat{\tau}(x, 0) \equiv0$。

常见建模方法

1. One-vs-All (OVA)

把多 treatment 问题拆成 $K$个二分类 uplift 子问题，每个子问题独立估计：

\[\hat{\tau}_k(x) = \hat{E}[Y(k) - Y(0)\mid X=x], \quad k=1,\dots,K\]

然后选择估计增量最大的 treatment：$\hat{t}^\star(x) = \arg\max_k\hat{\tau}_k(x)$。

优点是可以直接复用已有的二分类 uplift 模型。缺点比” 训练 $K$ 个模型” 更深一层：

样本利用率低：训练 $\hat{\tau}_k$ 时只用 treatment $k$ 和 control 两组样本，其他 treatment组的数据被丢弃
比较时偏差不可比（horse race bias）：$K$个独立模型各有不同方向、不同量级的偏差，做 argmax时会被相对偏差污染 —— 某个 $\hat{\tau}_k$系统性高估，就会被永远选中
不强制约束 $\hat{\tau}(x, 0) =0$

2. Multivalued S-Learner

把 treatment 当作多值类别特征喂进单一模型：

\[\hat{\mu}(x, t) = \hat{E}[Y \mid X=x,T=t]\]

预测时枚举所有 $t$，选 uplift最大的：

\[\hat{t}^\star(x) = \arg\max_t\big(\hat{\mu}(x, t) - \hat{\mu}(x, 0)\big)\]

这是 S-Learner 的多值版本，需要 unconfoundedness 对所有 $t$ 成立 + 重叠性扩展。优点是可以学到treatment 间的共享结构，所有样本都参与训练；缺点继承自S-Learner——treatment 信号可能被强正则” 抹平”。

3. Pairwise Comparison

对每对 $(j, k)$ 估计相对优势：

\[\hat{\tau}_{jk}(x) = \hat{E}[Y(j) - Y(k)\mid X=x]\]

需要 $\binom{K+1}{2} = O(K^2)$个模型。综合 pairwise 结果可用 Borda count、Bradley-Terry 等。

主要风险是传递性破坏：可能出现 $\hat{\tau}_{12} > 0$、$\hat{\tau}_{23} > 0$、但 $\hat{\tau}_{13} < 0$的环路（独立估计的不一致性）。所以 $K \ge4$ 时一般不直接用 pairwise。

4. DR-Learner / GPS 加权方法（更现代的做法）

直接对每个 treatment 构造 doubly robust 伪结果：

\[\tilde{Y}_i(t) = \hat{\mu}(X_i, t) +\frac{\mathbb{1}\{T_i=t\}}{\hat{e}_t(X_i)} \big(Y_i - \hat{\mu}(X_i,t)\big)\]

然后对 $\tilde{Y}_i(t) -\tilde{Y}_i(0)$ 做回归得到 $\hat{\tau}(x, t)$。优势是只要 $\hat{\mu}$ 和 $\hat{e}_t$中有一个估准就能保证一致性，且样本利用率高于 OVA。Causal Forest、EconML都提供了多 treatment 版本。

预算约束下的联合决策

更接近实际业务的问题是：在预算约束下，同时决定” 给谁干预” 和” 用哪种treatment”。设决策变量 $x_{it} \in\{0,1\}$ 表示是否对用户 $i$施加 treatment $t$（$t=0$ 表示不干预，$\text{gain}_i(0) = \text{cost}_i(0) =0$）：

第二条约束限制每个用户最多选一种treatment（包括” 不选”）。这是个多选择背包问题（Multiple ChoiceKnapsack Problem, MCKP），是 NP-hard 的。

实际中的近似贪心：

枚举所有 $(i, t)$ 对（$t \ne 0$），计算 $\text{ROI}_{it} = \text{gain}_i(t) /\text{cost}_i(t)$
按 ROI 全局降序排
依次选择，对每个用户只保留最先选中的那条（per-userdedup），直到累计 cost 达到 $C$

简单的” per-user argmax + global sort”（先给每个用户挑 ROI 最高的treatment，再全局按用户排）在 MCKP 下不是最优 —— 它丢失了” 差一档 treatment但 cost 更低” 的备选项。LP 松弛求 $\lambda^\star$ 后，每个用户独立选 $\arg\max_t (\text{gain}_i(t) - \lambda^\star \cdot\text{cost}_i(t))$，再二分搜 $\lambda^\star$ 让总 cost 接近 $C$，是更标准的解法。

连续 Treatment 场景

当 treatment是” 做多少” 的连续变量时（折扣力度、出价、曝光频次），目标变成估计剂量 - 响应曲线（Dose-ResponseCurve, DRC）。

问题定义

Treatment $t$ 取值在 $\mathcal{T} \subseteq\mathbb{R}$。在连续场景下 uplift 有两种合理定义：

绝对 uplift（相对不干预或基准剂量 $t_0$）

\[\tau(x, t) = E[Y(t) - Y(t_0) \mid X =x]\]

适合” 开 / 不开” 或” 加 vs 不加” 型决策。

边际 uplift（剂量每增加一个单位带来的收益变化）

\[\partial_t \mu(x, t) =\frac{\partial}{\partial t} E[Y(t) \mid X = x]\]

适合做剂量优化、寻找最优拐点。

两者背后都是同一条 DRC $\mu(x, t) = E[Y(t)\mid X=x]$，区别只是看积分还是导数。

常见建模方法

1. Dose-Response Network (DRNet, Schwab etal. 2020)

共享底层表示 + 多个 head 的神经网络结构：把剂量空间切成 $M$ 个子区间 $[t_m, t_{m+1}]$，每个区间一个 head，所有head 共享前几层 encoder：

\[\hat{\mu}(x, t) = \sum_{m=1}^M\mathbb{1}\{t \in [t_m, t_{m+1}]\} \cdot h_m(\phi(x), t)\]

共享 $\phi(x)$让样本利用率比独立模型高得多；区间内 $h_m(\cdot, t)$可以做线性 / 样条插值，避免边界跳跃。

2. 连续 Meta-Learners

把 Meta-Learner 框架扩展到连续 $T$，常见做法包括：

把 $t$ 作为输入特征的扩展S-Learner $\hat{\mu}(x, t) = f(x,t)$
在每个剂量分位点上训练 T-Learner、再插值
连续 X-Learner（结合 GPS 加权）

预测时对 $t$做网格搜索或梯度上升找最优剂量。

3. GPS 加权与 IPW 估计

用广义倾向性得分 $\hat{e}(t, x) =\hat{f}_{T \mid X}(t \mid x)$ 做核加权 IPW 估计：

\[\hat{\mu}(x, t) = \frac{\sum_i K_h(t -T_i) \cdot \frac{1}{\hat{e}(T_i, X_i)} \cdot Y_i}{\sum_i K_h(t - T_i)\cdot \frac{1}{\hat{e}(T_i, X_i)}}\]

其中 $K_h$ 是带宽 $h$ 的核函数。直接 IPW在密度估计偏小时方差爆炸，工程上常用：

Stabilized weights：$w_i= \hat{f}_T(T_i) / \hat{e}(T_i, X_i)$，分子是 $T$ 的边际密度，能大幅控方差
Weight clipping：把权重截在 $[0.01, 100]$ 之类的范围
Doubly robust 版本（如 Kennedy et al. 2017 的DR - DRC）

4. 现代神经网络方法

VCNet（Variational Counterfactual Networks）、SCIGAN 等专门为连续treatment 设计的网络结构，进一步把表示学习和 GPS调整结合起来，是近年研究的主流方向。

最优剂量选择

给定用户特征 $x$，预算约束下的最优剂量是带 $\lambda$ 的拉格朗日：

\[t^\star(x) = \arg\max_{t \in\mathcal{T}} \big(\text{gain}(x, t) - \lambda \cdot \text{cost}(x,t)\big)\]

在 $t$连续可导时，一阶条件给出：

\[\partial_t \text{gain}(x, t) = \lambda\cdot \partial_t \text{cost}(x, t)\]

也就是边际收益等于影子价格乘以边际成本 —— 每多投一个单位剂量，带来的额外收益必须刚好抵得上付出的额外成本。$\lambda$ 由全局预算约束 $\int t^\star(x) \, dF(x) \le C$反解出来。

实操上常退化为网格搜索：

在 $\mathcal{T}$ 上离散采样 $\{t_1, \dots, t_M\}$
对每个用户、每个 $t_m$ 预测 $\hat{\text{gain}}, \hat{\text{cost}}$
取 $\arg\max_m (\hat{\text{gain}}(x, t_m)- \lambda \cdot \hat{\text{cost}}(x, t_m))$
二分搜 $\lambda$ 让全局 cost命中预算

注意这里不能简单用 ROI = gain / cost排序：连续剂量下，最优解满足的是一阶条件（边际收益匹配边际成本），与ROI 的最大化不等价。只有在 cost 是 $t$ 的线性函数（即 $\text{cost}(x,t) = c(x) \cdot t$）时，ROI排序才与拉格朗日最优一致。

工程挑战

挑战	多 Treatment	连续 Treatment
因果识别	需要 unconfoundedness 对所有 $t$成立；每个 $t$ 都要满足重叠性 $P(T=t\\|X) > 0$	同上，且重叠性变成密度 $f_{T\\|X}(t\\|x)> 0$，对密度估计要求高
实验设计	多臂 RCT 或分层 switchback；样本量随 $K$ 线性增长	剂量随机化（如均匀采样剂量、或固定剂量集合 +随机分配）；密度需要足够覆盖
模型复杂度	OVA 是 $O(K)$，pairwise 是 $O(K^2)$；联合建模可缓解	需要学连续函数；GPS 估计本身就是个非平凡的密度估计问题
GPS 估计稳定性	离散 GPS 用多分类模型即可	条件密度估计（normalizing flow、kernel）容易在尾部不稳，需要stabilized weights / clipping
决策求解	MCKP，NP-hard，靠 LP 松弛 + 二分 $\lambda$ 近似	拉格朗日一阶条件 + 网格搜索；不能直接用 ROI 排序
反馈闭环	比二值更严重 —— 线上策略会让某些 $(X,t)$ 组合常年缺样本，重叠性持续退化	同上，且密度估计的偏差会被 IPW 放大

从工程角度看，这两类场景的落地难度明显高于二值treatment。一个普遍做法是先用二值 RCT 验证 uplift信号存在性、再扩展到多 / 连续treatment，避免一上来就在最难的设定下踩多重坑。

总结与展望

Uplift Modeling的核心，不是预测 “谁会转化”，而是估计 “干预会让谁发生净变化”。因此它解决的是一个更贴近业务决策的问题：在有限预算与副作用约束下，把干预资源留给最值得被影响的人。

围绕这个目标，本文依次讨论了以下几个问题：

第一，为什么传统预测只能回答相关性，无法回答反事实；
第二，潜在结果、CATE 以及无混淆性、重叠性、SUTVA 构成了 uplift的因果基础；
第三，S/T/X-Learner、Uplift Tree、Causal Forest分别对应不同的建模取舍；
第四，AUUC、Qini 与累计增益曲线用于评估排序是否有效；
第五，真正落地时还要把 gain-cost 建模、预算约束、平滑 treatment与反馈闭环修正串成完整策略链路。
第六，多 Treatment 和连续 Treatment 的场景里，建模方法应该如何改进

也正因为如此，uplift 的难点往往不只在模型，而在实验设计是否干净、gain与 cost是否定义完整、线上策略是否保留探索，以及回训时能否避免选择偏差持续累积。模型只是中间环节，策略优化才是最终目标。

继续往后看，更值得深入的方向包括：网络效应下的因果识别、多 Treatment与连续 Treatment 的联合决策，以及 uplift 与 contextualbandit、reinforcement learning 的结合。二值 uplift往往只是起点，真实生产问题通常会更复杂。

如果后面继续展开，我更想单独写几块工程细节：AUUC / Qini的实现坑点、Causal Forest / DR-Learner 的样本与特征设计，以及平滑treatment 和随机 holdout 的线上用法。

参考文献

Rubin, D. B. (1974). Estimating causal effects of treatments inrandomized and nonrandomized studies (Source). Journal ofEducational Psychology, 66(5), 688–701.
Künzel, S. R., Sekhon, J. S., Bickel, P. J., & Yu, B. (2019).Metalearners for estimating heterogeneous treatment effects usingmachine learning (PDF). Proceedings of theNational Academy of Sciences, 116(10), 4156–4165.
Wager, S., & Athey, S. (2018). Estimation and inference ofheterogeneous treatment effects using random forests (PDF). Journal of theAmerican Statistical Association, 113(523), 1228–1242.
Athey, S., & Wager, S. (2019). Estimating treatment effectswith causal forests: An application (PDF). ObservationalStudies, 5(2), 37–51.
Athey, S., & Imbens, G. W. (2016). Recursive partitioningfor heterogeneous causal effects (PDF). Proceedings of theNational Academy of Sciences, 113(27), 7353–7360.
Radcliffe, N. J., & Surry, P. D. (2011). Real-world upliftmodelling with significance-based uplift trees (PDF).Stochastic Solutions White Paper TR-2011-1.
Gutierrez, P., & Gérardy, J.-Y. (2017). Causal inference anduplift modelling: A review of the literature (PDF).In Proceedings of the 3rd International Conference on PredictiveApplications and APIs (PMLR, Vol. 67, pp. 1–13).
Hirano, K., & Imbens, G. W. (2004). The propensity scorewith continuous treatments (Source).In A. Gelman & X.-L. Meng (Eds.), Applied Bayesian Modeling andCausal Inference from Incomplete-Data Perspectives (pp. 73–84).Wiley.
Kennedy, E. H., Ma, Z., McHugh, M. D., & Small, D. S. (2017).Non-parametric methods for doubly robust estimation of continuoustreatment effects (PDF). Journal of theRoyal Statistical Society: Series B (Statistical Methodology),79(4), 1229–1245.
Schwab, P., Linhardt, L., Bauer, S., Buhmann, J. M., & Karlen,W. (2020). Learning counterfactual representations for estimatingindividual dose-response curves (PDF). Proceedings of theAAAI Conference on Artificial Intelligence, 34(4), 5612–5619.

死亡是凉爽的夜晚

2026-04-06T04:53:19.000Z

又到了清明时节，总能看到不少人在街头巷尾烧纸。

很长一段时间里，我对这个场景的第一反应都是害怕。看到路边燃起的火，闻到空气里纸灰的味道，我会下意识绕远一点。那种害怕并不完全来自火焰本身，而是因为它把 “死亡” 这件事，从一个遥远的词，忽然变成了日常生活里真实存在的东西。它不在新闻里，不在殡仪馆里，而是在你回家的路上，在夜色里，在风一吹就会飘起来的灰烬里。

后来我看了《寻梦环游记》，对这件事的感受慢慢变了。电影里那句 “死亡不是终点，被遗忘才是终点”，第一次让我意识到，烧纸未必只是阴森的仪式，也可能是一种温柔的挽留。原来生者记住逝者，不只是出于不舍，也是在让那个人以另一种方式继续存在。

这么想之后，那些我曾经远远绕开的场景，忽然也有了一点暖意。

也正是从那时起，我开始认真想：死亡到底是什么？我们为什么怕它？而当我们试着理解它时，它又会怎样反过来改变我们活着的方式？本文是关于 “死亡” 这一话题的一些碎碎念，祝开卷有益～

缺失的死亡教育

我们的文化里，很少谈论死亡。

它被小心翼翼地绕开，被替换成一些模糊的说法：“走了”、“不在了”。人们尽量不去直视它，好像只要不提，它就不会真正发生。

但问题在于，死亡并没有因此消失。

它只是从一种可以被经验的现实，变成了一种无法被处理的概念。我们知道它存在，却没有语言去理解它，也没有经验去安放它。

于是，当它真正逼近时，人往往显得措手不及。

更准确地说，我们恐惧的，往往并不完全是死亡本身，而是一种更难以描述的东西：叙事的中断。

一个人一生都在构建关于 “我是谁” 的故事，而死亡意味着这个故事会被突然截断，没有结尾，也没有解释。

一个从不谈论死亡的社会，某种程度上，也是不知道如何活着的。

死是一件必然会降临的事情

《我与地坛》里那句脍炙人口的话：死是一件不必急于求成的事，死是一个必然会降临的节日，也许能帮我们稍微解开死亡的神秘面纱。

一个人出生，这件事本身就已经包含了它的结局。这不是一个可以讨论的命题，而是一种被交付的事实；当这个事实被交到我们手中时，它的结果也已经一并被保证了。

死亡不是一种可能性，而是一种确定性。

很多时候，我们的焦虑来自一种习惯：把未来注定会发生的事，在当下反复体验。我们一遍一遍地想象终点，以至于忘了自己其实还在路上。

如果换一种方式去理解，死亡甚至带有一种奇怪的宽慰。

就像你在清晨起床，为一件艰难的事情奔波时，忽然想起远方还有一段长长的假期在等待。那假期不会消失，不会取消，只是还没有到来。想到这里，眼前的紧张会松动一点。

死亡也是类似的东西。

它在那里，不需要争取，也不会落空。正因为如此，它不必成为焦虑的来源。

甚至可以说，死亡是这个世界上少数真正公平的制度之一。无论一个人如何成功或失败，富有或贫穷，最终都会抵达同一个地方。

我们真正害怕的是什么

不过，承认死亡的必然性，并不等于恐惧就会立刻消失。

因为很多人真正害怕的，往往不是 “死” 这个结果，而是通往终点的那段路。

是疼痛，是衰老，是身体一点点失去控制；是尊严的剥落，是与亲人的告别，是意识到自己再也无法参与这个世界。

我们常常以为自己在害怕死亡，实际上害怕的，是通往终点的那段路，是那条路上往往会遇到的疼痛、失控与告别。

一旦把这一层区分开，有些问题就会变得更清楚。

死亡本身是一回事，痛苦、失控和告别是另一回事。把它们区分开，反而更接近真实，也更接近平静。

真正的死亡

电影《寻梦环游记》里，有一句很简单却又很动人的话：死亡不是终点，被遗忘才是终点。

Death is not the end of life, forgetting is the end of life

这句话之所以动人，是因为它悄悄改变了我们理解死亡的角度。

从生物学上看，死亡是身体的停止；但从另一个角度看，人似乎要经历两次死亡。第一次是肉体的消失，第二次是从他人的记忆中被彻底抹去。

而后者，才更接近一种真正的 “终结”。

因为只要还有人记得，一个人的某些部分就仍然在这个世界上以某种形式存在着：在叙述里，在回忆里，在别人的行为与选择里。

当然，记忆本身也会消散。

时间足够长，几乎所有名字都会被遗忘。于是一个更残酷的问题又摆在了眼前：如果终究会被遗忘，那活着的意义究竟是什么？

也许答案并不在 “被记住多久”。

存在并不依赖于它的持续时间。一个瞬间的真实，并不会因为它短暂就变得轻薄。记忆的长度，并不决定存在的重量。

生者所要面对的，不只是怀念

电影《破・地狱》里有一句话，道出了殡葬仪式的真正意义：“活人也有很多地狱要破的。”

所谓 “破地狱”，是香港传统殡葬仪式之一，本意是送先人进入另一个世界。但电影点破了另一层：仪式不只是为了死者，更是让活着的人，有机会放下那些纠缠在心里的愧疚、遗憾与未尽之言。

一个人的死，从来不只是 “他不在了” 这么简单。

对生者而言，它意味着一个称呼的消失，一种依赖关系的断裂，一部分日常秩序的坍塌。此后很长一段时间里，活着的人要做的，不只是怀念，而是重新学习如何生活：谁来接替那个角色，谁来保存那些习惯，谁来承受那些原本不属于自己的沉默。

所以，死亡之所以沉重，不只是因为一个生命结束了，也因为它迫使留下来的人重写自己的生活。

也正因为如此，纪念并不仅仅是为了死者。

纪念更像是在帮活着的人重新整理关系：承认失去已经发生，同时承认那个人仍然以另一种方式参与着我们的今天。不是神秘意义上的 “还在”，而是在我们说话的方式里，在某些习惯里，在某些不假思索的选择里。

仪式也好，纪念也好，最终都不仅仅是为了让死者安息，更是让生者能继续往前走。

不息的欲望与永恒的歌舞

《我与地坛》里，还有一段关于死亡的文字，我一直很喜欢

当牵牛花初开的时节，葬礼的号角就已吹响
但是太阳，它每时每刻都是夕阳也都是旭日。当它熄灭着走下山去收尽苍凉残照之际，正是它在另一面燃烧着爬上山巅布散烈烈朝辉之时。那一天，我也将沉静着走下山去，扶着我的拐杖。有一天，在某一处山洼里，势必会跑上来一个欢蹦的孩子，抱着他的玩具。
当然，那不是我。
但是，那不是我吗？
宇宙以其不息的欲望将一个歌舞炼为永恒。这欲望有怎样一个人间的姓名，大可忽略不计

太阳在落下山去的时候，同时也在另一面升起；同样的，一个人沉静地离开，总会有另一个生命在某处欢蹦着到来。

当然，那不是我。但更令人动容的地方，在于那句反问：那不是我吗？

如果从个体的角度看，这个问题似乎毫无意义。那个孩子有他自己的身体、记忆与命运，他并不是 “我”。

但如果稍微放宽一点视角，问题又没那么简单。

有人说，“生命是一团欲望：欲望不满足，会痛苦。欲望若满足，会无聊”。人生，就在痛苦与无聊之间摇摆。活着的人群就是不息的欲望。

构成我们的物质，会继续流动；生命这种形态，会不断重复；某种类似的欲望、冲动与意识，会在不同的人身上一次次出现。

所以，宇宙并不在意 “我是谁”，甚至不会注意到 “我曾存在过”。它在意的，只是某种形式是否持续发生，在意的是这场盛大的歌舞是否能永不落幕。一个具体的名字、一个具体的生命，在这个尺度下，随时可以被替代。

正所谓，“天地不仁，以万物为刍狗”。在天地的尺度下，死者、生者、你我，其实都并没有那么特殊。

这听上去是冷的。

但也正是在这种冷之中，某种更宽阔的东西开始显现出来：个体会消失，但并不等于一切都熄灭了。

死亡是凉爽的夜晚

如果把这些都放在一起看，死亡似乎不再只是一个单一的概念。

它不只是终结，也不只是消失。它更像一种状态的转换。

白天意味着持续的消耗：行动、选择、焦虑、对抗。人始终处在某种 “发热” 的状态中，像一台不停运转的机器。

夜晚则不同。

夜晚带来的是停止，是降温，是从紧绷中松开。不是毁灭，而是一种安静的退场。

如果生命是一场持续发热的过程，那么死亡不过是一次迟来的降温。

它不是骤然降临的黑暗，而是一种逐渐铺开的安抚。不是把一切夺走，而是让一切慢慢归于平静。

这样理解死亡，并不是为了制造一个漂亮的比喻，而是为了给人一种更可承受的观看方式。我们不必总把死亡想成唯一的深渊，也可以把它想成一种自然的停息。

它未必是骤然降临的黑暗，也可能只是漫长发热之后，一个终于到来的凉夜。

不要温和地走进那个良夜

但如果故事停在这里，它会变得过于平静，甚至带一点危险的安慰。

因为接受死亡，并不意味着可以轻易地放弃生命。

Dylan Thomas 在那首著名的诗里写道：不要温和地走进那个良夜。

这句话的力量在于，它与前面的一切并不矛盾。

死亡可以是凉爽的夜晚，但这并不意味着我们应该提前熄灭自己。恰恰相反，正因为终点已经被确定，过程才变得更加重要。

抗争并不是为了战胜死亡，那几乎是不可能的事情。抗争的意义在于，让生命在抵达终点之前，不至于变得稀薄。

我们无法改变故事的结局，但仍然可以决定这个故事的密度。

死亡意识真正珍贵的地方，也许就在这里：它会逼着我们重新排列生活中的轻重缓急。哪些关系值得珍惜，哪些愤怒其实无谓，哪些拖延只是因为我们假装自己还有无限时间。

到最后，它指向的或许并不是什么宏大的答案，而是一种更具体的活法：保留感受力，珍惜所爱，去过自己真正愿意认领的生活。就像《凡事发生必有利于我》里那段我很喜欢的话：

要兴致盎然地跟这个世界交手过招，做一个永远会为路边的树、天边的云、翻滚的浪、撒娇的猫、新一轮的满月、可口的饭菜、夏夜的晚风、冬天的白雪而欢呼雀跃的人。
要热气腾腾地活着，吃爱吃的食物、买喜欢的东西、穿漂亮的衣服、珍惜爱的人、做喜欢的事…… 先争取今天快乐，先争取开心地活在当下，先别管这种活法 “高不高尚” 或者 “有没有出息”。
希望你早日明白，真正应该焦虑的，不是孤独，不是没钱，也不是衰老，而是你从来没有按照自己喜欢的方式活过。

正因为生命有限，选择才有分量；正因为终点固定，途中如何度过，才真正构成了人生。

所以，也许更好的状态是这样：一方面，知道夜晚终会到来，因此不再恐惧；另一方面，在白天仍然尽力燃烧，不轻易退场。

有时候，我还是会在清明的夜晚经过那些烧纸的路口。

火光一闪一闪，纸灰在空气里慢慢升起，又落下。

我不再绕路了。

我会停在路口，看一会儿，然后继续回家。

夜晚终会到来。

但在那之前，我们仍要把白天过完。

场

2026-02-23T05:53:19.000Z

最近在读《创意行为: 存在即答案》，一本关于创作的书，里面有这么一句话

我们的目的不是制造艺术
而是要进入那美妙的境界
让艺术无可避免地发生

这句优美得甚至有些玄乎的句子，一下子把脑子里许多零碎的观点都拽了出来。比如关于创作的 “人只是上帝手中的一支笔”，“世界有分享欲，无时无刻都在找通灵者”；比如关于生活的 “与善人居，如入芝兰之室，久而不闻其香，即与之化矣”，Naval的 “three most important decisions in life: where you live, who you arewith, and what youdo”；亦或关于人性的 “人性之无分于善不善也，犹水之无分于东西也”、“性相近也，习相远也”

这些散落在不同维度的碎片，似乎都在论证着同一个我一直深以为然的判断：人是环境的产物。当然，这并不是说人只是任由揉捏的泥土。我们有反思、有抵抗、有重新选择的能力，只是这些能力从来不是凭空发生，而总要付出代价。也正因如此，环境才显得格外重要 —— 它决定了你要花多大力气，才能成为你想成为的人

环境不仅仅是空间，更重要的，是其中看不见却无处不在的 “场”。我们在特定的规则下，会不由自主地做出符合这些规则的行为，这些行为经年累月地沉淀，最终内化为我们的性格与命运。无论是工作、生活、创作，还是那幽微莫测的人性，都与场的引力息息相关。清醒地辨识自己身处何种场，觉察它对我们的无声浸润，进而去选择、去走向那与自身价值观共振的场 —— 这对一个人的长远发展与内心的平静，至关重要

本文是关于 “场” 这个话题的一些碎碎念，内容或许有些发散，祝开卷有益～

关于工作

规则与场

工作的 “场”，很大程度上是由考核机制塑造的

考核机制往往决定了人的行为。比如说对程序员而言，若考核代码行数，得到的便是臃肿冗长的实现；对客服而言，若考核响应速度，换来的便是快速打发而非真正解决问题；对基金经理而言，若考核资金规模，诞生的便是在牛市高点推出的那些需要数年才能回本的爆款基金。很多时候，我们以为自己在主动工作，殊不知只是对考核机制做出条件反射 —— 如同迷宫中寻找奶酪的老鼠，奶酪的位置一变，路径也随之改变

2025 年的前大半年，工作上可谓疲惫不堪。当时在《工作、体制化与自由》里曾这样记录：“最近一段时间很忙，忙到整个大脑带宽被打满，回到出租屋只想躺平放空，或是忍不住无意义地刷短视频；忙到觉得自己工种变了（变成了一个消防员，天天在救火）；忙到甚至没有时间去做更长期的规划；能明显感觉到自己的词汇量、语义精度、表达能力和表达欲在迅速下降，同时自己对知识、对他人、对世界的好奇心和热情，似乎正在被浇灭”

如今复盘那段经历，觉得很重要的一个原因还是当时业务目标定得过于激进。在这个 “场 “下，看到的是从上到下的焦虑，让团队长期陷于追逐短期收益的泥淖（即便这与长期目标相悖），所在方向人力不足又雪上加霜。不是说短期目标不对，因为任何业务发展都不可避免地存在长短期目标的配合，只是这种状态将个人的精力耗散于琐碎的应急，而那些真正重要的事 —— 业务的长期发展、个人的成长规划 —— 却被无情抛诸脑后。长远来看，这样的短视，对组织与个体都是一种消耗

这种高压而短视的工作之 “场”，还催生了另一个问题：对即时反馈的渴求，以及随之而来的 “体制化” 现象。就像码头工人的 “早酒文化” 一样 —— 在繁重劳作后，他们需要烈酒来麻痹身体、换取片刻的欢愉。我们在高压环境下，将所有精力投注于短期的、重复的任务，收到的正反馈往往稀薄。更多时候，只是已有知识的反复调用，枯燥流程的无限循环，如同被惩罚的西西弗斯，一次次将巨石推向山顶，又眼睁睁看它滚落。人若长久浸淫于这种没有正反馈的环境中，生命力会迅速流失，不得不依靠 “低级娱乐” 来输入廉价的快乐。这也是为什么许多人下班后选择刷短视频，而非拿起书本 —— 那不是懒惰，那是求生。但这是一种令人绝望的平衡

关于短视频的危害，已无需赘言。当工作中的负反馈与业余时间的低级娱乐达成某种脆弱的平衡后，任何试图打破这种平衡的行为，都会变得格外艰难。譬如你决心告别短视频，尝试在业余时间学习新技能 —— 这会让工作中的负反馈失去宣泄的出口；同时，陌生领域带来的新负反馈又会叠加其上。两者交织，人便很难坚持下去。大多数人自我提升计划的夭折，根源大抵在此。久而久之，人便被环境 “体制化”—— 身体、大脑、认知，乃至性格，都朝着融入当前环境的方向生长，只为让自己不那么痛苦

当然，说离开很容易，做到却很难。房租、家庭责任、市场周期、履历风险，都会把人钉在原地。很多时候，我们能做的未必是立刻跳出这个场，而是先在缝隙里保住一点不被同化的东西：一项仍愿意精进的技能，一段能真正喘口气的业余时间，一个不只和你谈KPI 的朋友。先让自己不至彻底枯萎，再等待迁移的时机

人与场

塑造工作之 “场 “的更根本的一个因素，是人

如果说考核机制是场的骨架，流程规范是场的血肉，那么人 —— 那些制定规则的人和朝夕相处的人才是场的灵魂。骨架可以被设计，血肉可以被填充，但灵魂决定了这个场是温暖还是冰冷，是让人向上生长还是日渐枯萎

首先是那些制定规则的人。业务目标由管理者确立，目标决定组织架构，架构衍生考核机制，机制最终塑造你的行为。这是一条从决策者案头一路延伸到每个人屏幕前的因果链。你以为是自己在选择如何工作，其实很多时候，你只是在顺应那个被设计好的轨道。管理者手中的笔，勾勒的是你日常的地形图 —— 哪里是平原可以驰骋，哪里是高山需要攀爬，哪里是沼泽会让你陷进去。他们未必有意如此，但每一个目标的设定、每一个指标的敲定，都在无声地改写你每天的选择

而比目标更不容易被观察到的的，是企业文化里那些 “虚” 的东西 —— 使命、愿景、价值观。它们听起来像墙上的标语，像年会上的口号，但却会渗透进每一次会议、每一封邮件、每一个决策里。它决定了一件事被讨论时，是 “这样做能短期交付” 优先，还是 “这样做是对的” 优先；决定了一个人犯错时，是被问责还是被鼓励；决定了一个团队面对压力时，是互相甩锅还是彼此托底。那些看似虚无的词语，最终会变成你每天呼吸的空气 —— 看不见，却无时无刻不在塑造你和企业

然后对你影响更频繁的场，是你那些朝夕相处的同事。同事是你每天见面最多的人，他们是你在茶水间吐槽时的听众，是你在困惑时下意识参照的坐标，是你在疲惫时抬头看见的镜子。你看着他们如何应对困难，如何庆祝成功，如何在加班深夜互相说一声 “先回了”—— 这些细碎的、重复的、不假思索的瞬间，才是你真正浸泡其中的那个场

一个好的同事群体会形成一种无声的引力：当你想要敷衍时，看到他们在认真，你会不好意思；当你想要放弃时，看到他们还在坚持，你会再撑一下；当你陷入自我怀疑时，他们随口一句 “你可以的”，可能比任何激励都管用。反过来，一个消耗型的同事群体也会慢慢拖垮你 —— 那些习惯性抱怨的人，那些把责任推给别人的人，那些对任何事情都说 “就这样吧” 的人，他们的存在本身就在悄悄改变你对 “正常” 的定义

对于那些不止于拿一份工资、按点上下班，而是把工作产出视为自己职业生涯作品的人来说，这一点尤为关键

因为当你在意作品时，你交付的不只是时间和劳动力，还有你的审美、你的判断、你对自己的期待。你希望经手之事能打上自己的印记，哪怕微小，也是骄傲。而这样的你，对所在的场会格外敏感 —— 因为场决定了你的作品能否诞生，以及诞生的过程是滋养还是消耗

如果所做的事情不符合自己的价值观，每一天都会是一场漫长的自我说服。你打开文档写标题时，心里知道这个方向不对；你在会议上点头时，脑子里有个声音在说 “这不是我想要的”。那种割裂感不会杀死你，但它会一点点抽干你 —— 你开始对工作失去热情，对产出失去骄傲，对 “作品” 这个词失去感觉。而做什么事，往往不是你能决定的。多数时候，是leader 定方向，你负责执行；更幸运的情况下，是你和 leader共同讨论决定。但无论哪一种，如果最终的方向与你相信的东西背道而驰，你都要付出双倍的能量：一份用来完成任务，一份用来安抚自己

如果一个大项目需要多方合作，你却遇到不给力的合作方，那种痛苦会像钝刀子割肉。你盯着进度条，发消息没人回，开会时对方永远说 “在做了”，交付时质量永远差一截。最终卡点不在你这里，结果却依然不符合预期 —— 你看着那个不如人意的作品，知道它本可以更好，但它就这样被拖成了平庸。你甚至不知道该怪谁，只能把烂摊子收拾完，然后告诉自己 “下次注意”。但下次呢？下次可能还是同样的人

如果身处一个形式大于实质的环境，你最需要的不是业务能力，而是表演能力。你要学会在汇报时把三分说成七分，在会议上提出正确但不重要的问题，在邮件里抄送该抄送的人而不是真的解决问题。你每天都在演戏 —— 演忙碌，演配合，演一切正常。慢慢地，你发现自己真的变成了一个演员，连真实的想法都要先问自己 “这能说吗”。那种异化感，比加班更累。

所以，对个人而言，选择团队就是选择日常。选择一个做事风格与价值观跟自己一致的团队 —— 这样你不需要每天和自己打架；选择跟优秀的人一起共事 —— 这样你会被推着往前走而不是被拽着往下沉；选择一个能平等交流、对事不对人、能碰撞出更多想法和作品的环境 —— 这样你的每一次发言都有回响，你的每一份付出都能被看见。这些听起来像理想主义，其实是最务实的自我投资。因为你每天在怎样的场里呼吸，你就会长成怎样的人

从这个角度来说，对管理者而言，组建优秀的团队、营造平等开放的讨论环境，不是锦上添花，而是首要的任务。管理的本质是激发善意和潜能 —— 这句话被说太多次，反而容易被忘记。但真正的好管理者明白：你不需要时刻盯着谁，不需要反复强调规则，你只需要把对的人聚在一起，给他们一个可以安心说话、放心做事的地方。剩下的，他们会自己完成。

因为一个好的工作场，本身就是最好的管理者。它让身处其中的人不由自主地向上生长 —— 不是因为有人逼，而是因为周围的人都在向上，因为讨论问题时那种纯粹的氛围，因为看到自己的作品一点点成型时的满足。在这种场里，努力不需要动员，成长不需要催促。你只是在那里，就自然会朝着光的方向，一点点长成更好的自己

场与人

工作的场，也深刻地影响着个人的长期发展路线

在互联网公司里，常常能观察到两类角色：IC（Individual Contributor）与Manager。Manager往往都是那批晋升较快的人，表面上看起来是能力使然，但剥开来看，也许更重要的一个因素是 —— 他们被放在了一个能持续收到正反馈的场里

这个场会不断给他们新的刺激：第一次带人，第一次定方向，第一次为团队争取资源，第一次在高层面前汇报。每一次新尝试，无论成败，都会带来新的经验；每一次经验积累，都会转化为下一次机会的入场券。他们被置于一个 “快速成长” 的轨道上，这个轨道本身就在推着他们前行 —— 像冲浪者被浪推动，不需要拼命划水，只要站稳，就能向前。一个人因业务需要晋升为管理者，便获得了管理经验；有了管理经验，便有资格带领更大的团队；下一次机会来临时，那个有经验的人自然会进入候选名单。这不是循环论证，这是场的正反馈

而另一些人，年复一年做着同样的事，在同一个岗位上原地踏步。并非他们不够努力 —— 他们可能比任何人都努力，每天最早到最晚走，交付稳得出错率极低。只是他们所在的场过于稳定：稳定的流程、稳定的任务、稳定的预期

稳定本身不是坏事，甚至是一种福利。但当稳定成为一种常态，场就开始悄悄改变它的性质。你不再需要学习新东西，因为老办法够用；你不再需要挑战自己，因为舒适区很安全；你不再需要抬头看路，因为脚下的路你已经走了十年。渐渐地，你发现自己被困住了 —— 不是被人锁住，而是被 “不需要改变” 的惯性裹挟。那个场像一潭水，起初还能泛起涟漪，后来慢慢变成死水，而你成了水底的石头，被水流磨得光滑圆润，却再也动不了分毫

最残酷的地方在于：不是你不愿意动，而是那个场已经不再给你动的理由和机会。你没有新的任务，所以没有新的技能；没有新的挑战，所以没有新的经验；没有新的机会，所以没有新的履历。你以为自己在积累十年经验，其实只是把第一年的经验重复了十次。如果你一直做老的事情，又怎么可能诞生新的事物呢？

不过，稳定也未必一定通向停滞。若你仍在主动扩展边界、打磨技艺、理解更深的规律，那么同一件事做十年，也可能是把一口井继续挖深，而不只是在地表原地踏步。问题不在于稳，而在于那个场是否还允许你继续生长

当然，这并不是说 Manager 就一定比 IC好，也不是说晋升快的人就一定更幸福。每种角色都有自己绕不过去的烦恼：管理者要背更大的锅，要处理更多的人际摩擦，要在上下之间反复平衡；管理者也逃不过大龄问题，尤其是国内的就业环境里，中年危机的阴影一样会笼罩。而那些在稳定场里的人，虽然晋升慢，但也可能拥有更可控的生活节奏、更少的焦虑、更多的陪伴家人的时间。得失之间，冷暖自知

但无论你是 IC 还是Manager，无论你在正反馈的浪尖还是在稳定场的深处，最关键的始终是那件事：你能不能让自己一直保持成为一个有 “价值” 的人，保持更新和学习的能力，在面对新事物时依然有初学者的好奇和勇气

尤其是在互联网行业，变化是唯一的常量。今天的技能明天可能过时，今天的经验后天可能成为包袱。你需要付出数倍的精力和时间，去抵抗那个把你往下拉的惯性 —— 而这，本来就是高薪礼物背后，暗中标好的价格

所以，当你发现自己在一个过于稳定的场里，不妨问自己一句：是我选择了稳定，还是稳定选择了我？是我主动留在这里，还是我已经走不动了？

关于生活

最初的场

生活的场，最早来自原生家庭

我们许多行为模式、情绪反应，乃至对世界的看法，都是在原生家庭中养成的，毕竟我们都说小孩就是一张白纸。童年时父母如何相处，我们往往便以为亲密关系应当如是；父母如何面对问题，往往会影响我们处理问题和矛盾的方法。这不是基因的刻写，而是我们从小浸泡在那个场里，像海绵一样无声地吸收了一切 —— 不仅是那些刻意教导的道理，更是那些未被言说的沉默、那些情绪暗涌的褶皱、那些日复一日重复的日常。我们学会了在争吵时是爆发还是隐忍，在失落时是倾诉还是封闭，在获得时是安然接受还是惶恐不安。这些都不是课堂上的知识，而是浸润在骨子里的呼吸

然而，成年后的我们常常面临一个困境是：那个在前二十年塑造了我们的 “场”，未必适合现在的自己，甚至，会反噬自我。许多人一辈子都活在原生家庭的影子里 —— 明明早已独立，过年回家时却会退化成青春期的叛逆少年，为了一句饭菜的咸淡而莫名动怒；明明已经有挣钱能力，却仍旧被过往贫穷的阴霾笼罩着，小心翼翼不敢花一分钱，仿佛一旦放松警惕，就会坠回那个匮乏的深渊；明明向往亲密关系，却因为父母在童年的争吵打骂留下的记忆而因噎废食，在爱来临时下意识推开，在幸福靠近时转身逃离。这不是他们不够成熟，而是那个 “家庭的场” 太过强大 —— 熟悉的气味、熟悉的语调、熟悉的争吵模式，一旦踏入，便被瞬间激活，如同按下旧日程序的开关。身体比意识更诚实，它记得所有的恐惧、委屈和无力

这几年流行一种说法 “重新把自己养育一遍”，其核心在于，当我们意识到原生家庭的场不再适合当下的自己时，便要主动去构建新的场：结交新的朋友，尝试新的生活方式，建立属于自己的日常仪式。这个过程，如同在一片荒芜中重新开垦花园 —— 需要时间，需要耐心，也需要勇气。你要学着像理想中的父母那样对自己说话：跌倒时不是斥责 “你怎么这么不小心”，而是轻声问 “疼不疼”；疲惫时不是咬牙硬撑，而是允许自己停下来。你要为自己营造新的场域 —— 也许是清晨的一杯咖啡，也许是傍晚的独自散步，也许是和那些懂得倾听的朋友的相聚。在这些新的空间里，你慢慢练习：练习说出真实的想法，练习接纳自己的不完美，练习在恐惧袭来时仍然向前走一步

这个过程，正是心理学家所说的 “精神弑父母”—— 不是对父母的否定和抛弃，而是在精神上完成与他们的分离。弑，是为了不再被他们的影子笼罩；弑，是为了让自己从过去中解脱出来，真正成为自己的主人。这不是背叛，而是一种深刻的忠诚 —— 对自己生命的忠诚。当你终于能够分辨哪些情绪是你的，哪些是从那个家庭场里继承的；当你能够选择用不同于父母的方式去爱、去生活、去面对困难。那一刻，你并没有离开他们，而是终于有能力以平等的、完整的人的身份，与他们重新相遇

这注定是一场残酷而温柔的告别，也是一次艰难的涅槃。你埋葬的，是那个困在旧日场里的自己；你迎来的，是一个可以自主选择生活场域的人。这片新开垦的花园，终将开出你自己的花

而这一切的前提，往往是经济独立。我一直相信，经济独立才能带来精神独立。因为只有远离了父母和原生家庭的那个场，你才能真正看清那个场对你的影响。虽然在很多外人看来，“富二代” 很幸福，事实上也的确如此，他们能够轻易得到很多人穷其一生也许都无法企及的东西，但他们往往也有一种特殊的 “苦”：虽然很有钱，却很难脱离原生家庭的那个场。钱是从家里来的，关系是家里给的，甚至婚姻都要听家里的安排。对于大部分无法独立的二代们，他们被困在一个镀金的笼子里，笼子很美，却终究是笼子

这笼子的栏杆不是铁的，而是由优渥的生活、体面的社会关系和不容辜负的期待编织而成。你很难反抗一个给了你一切的人 —— 哪怕他们同时也在拿走你最重要的东西：你自己。当你的银行卡每个月准时到账，当你住着父母名下的房子，当你求职时第一个想到的是 “家里有没有关系”，你就很难在饭桌上说出那句 “我不想过你们安排的人生”。因为潜意识里你知道，那句话的代价太高了：不只是争吵，而可能是生活本身的崩塌。这不是软弱，而是人性 —— 人在依赖中很难生出真正的反骨

而普通人家的孩子，或者那些早早切断脐带的人，他们的独立往往从第一笔自己挣来的工资开始。那笔钱可能不多，交完房租所剩无几，但它有一个无可替代的意义：它证明了你可以靠自己活下来。当你知道即使全世界抛弃你，你还有能力租一个容身之处、买一碗果腹之食，你的脊梁就开始直起来了。父母催婚时，你可以平静地说 “这是我的事”；他们干涉你的选择时，你可以微笑着听完，然后继续走自己的路。这不是叛逆，而是因为你有了底气 —— 你不再需要为生存付出自我的代价

这就是为什么说经济独立是精神独立的基石。它不只是钱的问题，而是那个 “场” 被打破的开始。当你搬出原生家庭，住进自己租的小屋，哪怕只是十平米，你也会发现：原来房间可以按自己喜欢的方式布置，原来晚归不需要向谁解释，原来沉默的时候是真的安静，而不是在等待下一场争吵。你在建造自己的场 —— 虽然简陋，但它属于你。慢慢地，你开始用自己挣的钱做决定：报一门想学的课，去一个想去的地方，买一本父母不会理解的书。每一个微小的选择，都是在对自己说：我的人生，我来写

而那些困在镀金笼子里的人，他们的困境恰恰在于：笼子太舒服了，舒服到让人忘记自己在笼中。他们从未真正体会过 “靠自己活下来” 的那种原始的、扎扎实实的底气。父母的爱与控制缠绕得太紧密，密到分不清哪是祝福哪是枷锁。他们当然可以一辈子衣食无忧，但也可能一辈子都无法回答一个问题：如果没有父母，我是谁？所以精神弑父母的第一步，往往是离开那个 “场”。而离开，常常从经济上的 “断奶” 开始。不是要你与父母决裂，而是要你证明给自己看：我可以。当你用自己的双手托住自己的生活，你才能以平等的姿态回到父母面前，不再是那个需要被保护的孩子，而是一个独立的、完整的成年人。那时，你与他们的关系才能真正从 “依赖与被依赖” 变成 “爱与爱”

第三个场

如果说摆脱原生家庭的 “场” 是我们前半生需要解决的课题，那组建自我的家庭则是我们后半生需要解决的课题。而在我们组建家庭中寻找的伴侣，会为我们构建另一个影响一生的场 —— 这一次，你不是被动的接受者，而是主动的建造者

你选择的那个人，带着 ta 自己的原生家庭的气味、温度、习惯和裂痕，走进你的生命。你们相遇时，不只是两个人在相遇，而是两个 “场” 在相遇 —— 你从小浸泡的那些沉默与喧哗，ta 童年时学会的隐忍与爆发，你们各自从父母那里继承的爱的语言和伤人的方式，都悄悄藏在你们的眼神、语调和不假思索的反应里。刚开始恋爱时，你们以为相爱就是一切；直到住到一起，才会发现原来牙膏从中间挤还是从底部挤，吵架后是需要拥抱还是需要独处，节日要不要庆祝，生病时是被照顾还是被嫌弃 —— 这些看似微小的事，背后都是两个 “场” 的碰撞。那些碰撞不是谁对谁错，而是两种 “正常” 在试探彼此的边界

而奇妙的是，你们正在共同建造第三个场。这个新的场，既不是你的原生家庭的复制品，也不是 ta 的，而是你们两人一砖一瓦搭建起来的、独属于你们的世界。在这个世界里，你们会慢慢形成自己的语言：某个眼神代表 “我累了”，某句话成了只有你们才懂的笑话，某个角落是争吵后各自冷静的坐标。你们也会形成自己的规则：如何分配家务，如何面对金钱，如何在疲惫时依然给对方留一盏灯。这些日常的、重复的、不起眼的瞬间，就像水珠一样，一滴一滴，最终汇聚成你们共同浸泡的那个 “场”

这个场的意义在于：它既是港湾，也是土壤。在外面的世界受伤时，你回到这个场，能被理解、被接住、被疗愈 —— 那些原生家庭没能给你的安全感，可能在这里慢慢生长出来；而那些你从童年带来的伤口，也可能在这个场的滋养下，第一次有机会真正愈合。同时，这个场也在无形中塑造着你们：好的亲密关系不是让人停留在原地，而是让人在安全的土壤里，长出新的枝桠。你可能发现，自己变得比以前更柔软了，或者比以前更勇敢了 —— 那不是你刻意的改变，而是这个新的 “场” 日复一日熏陶的结果

所以，选择另一半，某种程度上是在选择自己的下半生。你选择的不只是一个爱人，而是一种日常，一种氛围，一种彼此塑造的力量。你们会一起面对柴米油盐，也会一起经历风雨飘摇；会在平凡的日子里互相打磨，也会在关键的时刻彼此托举。那些在原生家庭中缺失的、受伤的、未完成的，有可能在这个新的场里被重新修复，当然也有可能被进一步放大将你彻底吞噬，关键还是取决于你构建了一个怎么样的场

一个良好的家庭的场的建造并不容易。它需要你们在争吵后依然选择沟通，在疲惫时依然愿意看见对方，在熟悉到几乎麻木的日常里，依然记得最初为什么选择彼此。它需要你们不断觉察：哪些情绪是当下的事，哪些是从过去带来的旧伤；哪些反应是对方的错，哪些是自己原生家庭种下的雷。真正的亲密关系，不是两个完美的人相遇，而是两个带着伤口的人，选择在彼此面前慢慢疗愈，同时小心不去碰痛对方

与之相反的是，一个不良的家庭环境里，两个人的伤口不但没有互相疗愈，反而彼此撕扯。你童年被抛弃的恐惧，被对方的若即若离精准触发；你从小目睹的争吵模式，在自己身上完整复刻。你恨父母当年的歇斯底里，却发现自己吼出的话和当年的父亲一模一样；你发誓不要像母亲那样隐忍，却一次次咽下眼泪假装一切都好。那个场像一面镜子，照出你最不想看见的自己，而你被困在镜中，不知如何挣脱

所以，是否要选择第三个场，以及能否建好它，成了现代人面临的深刻难题

有些人终其一生都无法建好这个场。不是因为他们不努力，而是因为他们从第一个场里带来的东西太重了。那些未曾愈合的伤口，那些未曾言说的恐惧，那些被刻进骨子里的相处模式，会在每一个深夜、每一次争吵中浮现，把两个人都拖进漩涡

有些人，干脆选择不建。他们看过太多失败的例子，听过太多破碎的声音，宁愿一个人待在安全的孤独里，也不愿冒险去建造一个可能坍塌的场。他们说 “一个人也挺好的”、说 “婚姻不是必需品”、说 “爱情最后都会变成亲情”。这些话都有道理，但夜深人静时，偶尔也会想起那个问题：如果有一个场，可以让你卸下所有防备，你愿不愿意试试？

更复杂的是，《一起这种艺术》，终究是两个人的作品。即使你想建，也需要找到一个同样想建的人。两个带着各自场的人，要在碰撞中磨合，要在分歧中妥协，要在漫长的岁月里一次次选择对方 —— 这本身就是一个奇迹。而这个奇迹发生的概率，比你想象的要低。如同在《一加一》中Eason 最后的独白

其实…… 有冇呢个人……
根本有冇呢啲嘢嘅呢？

关于创作

创作的场，更加玄妙

上帝的手

有人说，创作者只是上帝手中的一支笔，上帝只是通过你把这些内容写了出来。而很多创作者都有过这样的体验：有时候灵感如泉涌，笔下生花；有时候大脑一片空白，对着空白文档半天敲不出一个字。我们以为这是灵感的问题，但也许这只是 “创作的场” 的问题 —— 不是你没有能力，而是你没能进入那个可以接收信号的频率

在《创意行为: 存在即答案》里有一段让人印象深刻的话，“在我们所参与的这个更大的创造里，我们不是指挥者。我们在被指挥。艺术家遵循宇宙的时间表，正如自然里的一切成员。如果你有一个激动人心的想法，又不把它变成现实，那这个想法通过另一个创作者找到表达的出口也不奇怪; 这不是另一个艺术家窃取了你的想法，而是这个想法的时机已到 “

这段话也许揭示了这个一个令人敬畏的事实：想法不是你的私有财产，它们是宇宙的访客，你只是它们暂时停留的房间。如果你关上门，它们就去敲别人的门。你以为是你抓住了灵感，其实是灵感选择了你 —— 而你唯一能做的，是让自己的房间保持开放、整洁、有人居住的气息

伟大的作品，似乎都有自己的生命，它们只是在寻找合适的 “通灵者” 把自己表达出来。艺术家或者说创作者不是创造者，而是宇宙广播的翻译员。他们的工作是汲取这些信息，转译它们、分享它们。那些流传千年的杰作，不是某个人 “想” 出来的，而是某个人 “接” 住的

那往往是哪些人接住这些想法呢？书里提到最好的艺术家往往是那些天线极为敏感的人 —— 是那些在特定时刻能在共振中汲取能量的人。很多伟大的艺术家最初发展出敏感的天线不是为了创造艺术，而是为了保护自己。他们要保护自己，因为痛苦对他们来说比别人更强烈。他们对事物感觉更深。正因为如此，他们才能接收到那些细微的信号。这是一份天赋的诅咒，也是诅咒中的礼物：你感知到的痛苦比别人深，你能接收到的回响也比别人远

就好像在《我与地坛》里，史铁生对自我发出的怀疑

凭什么我总能写出小说来呢？凭什么那些适合做小说的生活素材就总能送到一个截瘫者跟前来呢？人家满世界跑都有枯竭的危险，而我坐在这园子里凭什么可以一篇接一篇地写呢？

双腿的残疾约束了他的行动范围，却也赠与了他异常强的感受力，强到地坛里一阵微风掠过树梢，一束斜阳落在荒草上，甚至一个默默走过的身影，都能在他心里留下比常人更久、更深的回响。别人眼里一闪而过、转瞬即逝的细小事物，在他那里却会慢下来，停下来，沉下去，最后一点点长出意义。也正因如此，当他看到那个漂亮而不幸的小姑娘时，才会继续往下想，写下这样一段近乎残酷、却又极深的追问（ps,笔者非常喜欢这段文字）：

谁又能把这世界想个明白呢？世上的很多事是不堪说的。你可以抱怨上帝何以要降诸多苦难给这人间，你也可以为消灭种种苦难而奋斗，并为此享有崇高与骄傲，但只要你再多想一步你就会坠入深深的迷茫了：假如世界上没有了苦难，世界还能够存在么？要是没有愚钝，机智还有什么光荣呢？要是没了丑陋，漂亮又怎么维系自己的幸运？要是没有了恶劣和卑下，善良与高尚又将如何界定自己又如何成为美德呢？要是没有了残疾，健全会否因其司空见惯而变得腻烦和乏味呢？
我常梦想着在人间彻底消灭残疾，但可以相信，那时将由患病者代替残疾人去承担同样的苦难。如果能够把疾病也全数消灭，那么这份苦难又将由（比如说）相貌丑陋的人去承担了。就算我们连丑陋，连愚昧和卑鄙和一切我们所不喜欢的事物和行为，也都可以统统消灭掉，所有的人都一样健康、漂亮、聪慧、高尚，结果会怎样呢？怕是人间的剧目就全要收场了，一个失去差别的世界将是一潭死水，是一块没有感觉没有肥力的沙漠。
看来差别永远是要有的。看来就只好接受苦难 —— 人类的全部剧目需要它，存在的本身需要它。看来上帝又一次对了。
于是就有一个最令人绝望的结论等在这里：由谁去充任那些苦难的角色？又有谁去体现这世间的幸福、骄傲和快乐？只好听凭偶然，是没有道理好讲的。
就命运而言，休论公道

敏感的人并不一定更幸福。很多时候，他们只是更容易受伤，更容易被刺痛，更容易被命运里那些细小却锋利的部分划开。可也正因为裂口更深，外部世界才更容易渗进来。同样一件事，落在普通人身上也许只是 “经历过”，落在天线敏感的人身上，却会变成 “必须回应”。那些素材不是偏爱他，而是他比别人更难对它们无动于衷。世界向每个人发出信号，但只有少数人会被那信号真正击中

所以，所谓创作者的天赋，很多时候并不只是想象力更丰富、技巧更熟练，而是他对世界的痛感、羞耻感、悲悯、困惑都更强一些。他更容易被一朵花的盛开打动，也更容易被一个人的命运刺伤；更容易从一片寂静里听见回声，也更容易在平常无奇的生活里听见命运的暗流

从这个意义上说，《我与地坛》这本把哲学写成文学的优秀作品，不是因为苦难文学，而是因为史铁生 “敏感” 到把苦、把静、把命运加诸于自己的那部分重量，全都接住了，然后慢慢转译成了文字。不是每一个受苦的人都会写作，但很多真正有力量的写作者，都是先被生活刺痛过的人。痛苦本身不会自动生成作品，可它常常会把人的天线逼得更长、更细、更靠近这个世界隐秘的震动

在场

我们如何拾取既无法收听，也无从定义的信号呢？答案不是去寻找，也不是试图去预测或分析。相反，我们创造一个开放的空间，允许它在里面存在。这个空间暂时卸下了日常堆积、堵塞的思绪，像真空一样，把宇宙已经解锁的想法汲取出来。正如书里所说的那句话：“我们的目的不是制造艺术，而是要进入那美妙的境界，让艺术无可避免地发生 “

但这并不意味着创作只靠玄妙的天启。开放的空间不是躺在那里等天上掉东西，它仍需要手艺作底、输入作养料、反复练习作容器。没有长期的阅读、观看、修改与失败，再敏感的天线也常常只能收到杂音

这个境界是什么？是你放下 “我要写一篇好文章” 的执念，只是让自己成为通道；是你不再用头脑构思，而是用整个身体去感受；是你允许自己写出一堆垃圾，却在垃圾堆里发现了一颗钻石。创作最吊诡的地方在于：你越是想抓住它，它越是逃逸；你越是放松，它反而找上门来。如同Oscar Wilde 说的 “Life is too important to be takenseriously”（生活过于重要，以至于不能被认真对待），艺术，或者说是创作，亦是如此

如果你开始写一首歌，那就一口气把它写完。最初的灵感蕴含一种生命力，可以牵引着你完成整个作品。有些细节没达到最好的水平不要紧，完成草稿即可。通常而言，一个完整而不完美的版本，比看似完美的小片段更为有益。因为那个不完整的版本里，藏着作品全部的 DNA—— 你随时可以回来修改、打磨、重塑，但骨架已经立起来了。而完美的小片段，就像一颗漂亮的牙齿，没有嘴可以安放。当一个想法逐渐清晰，或者我们已经动笔写下一个引子时，我们可能会觉得自己已经抓到了诀窍，剩余部分会水到渠成。但如果这时候就停下，任凭最初的火花逐渐消退，要重新点燃可能就难了

灵感也免不了受到熵定律的约束，宇宙的能量是流动的，你截留的那股洪流，如果不及时疏导让它奔涌而出，它就会慢慢干涸、淤塞、改道。你以为你保存了它，其实你失去了它。这就是为什么许多创作者都有这样的经验：半夜醒来想到一个绝妙的句子，心想 “明天再记下来”，结果第二天怎么也想不起来。不是记忆出了问题，而是那个句子已经离开了，去找另一个愿意在深夜里起身的人

所以，创作的 “场 “，说到底是一种 “在场 “—— 你让自己真正地在那里，空在那里，也准备好在那里。像一片土壤等待种子，像一张唱片等待唱针，像深夜的收音机等待那一段飘忽不定的频率。你无法强迫灵感降临，但你可以让自己成为一个灵感愿意停留的地方。而这也不是被动的等待，而是一种很具体的劳动：按时坐下，持续输入，诚实修改，在没有感觉的时候也先把手动起来。很多时候，灵感不是努力的对立面，而是努力累积到某个临界点后忽然亮起的火。而当你终于进入那个场，你会发现：不是你写完了作品，是作品写完了你。你从另一端走出来时，比进去时更丰富了一些 —— 因为在那短暂的时间里，你曾与某个更大的东西连接过

我很喜欢孟岩写的这篇文章《存在即答案》里面的这段话

创作不是刻意的追逐或费力的雕琢，而是一种专注、放松的倾听和等待。它要求我们不断吸收优秀的东西，塑造我们的品味和对好东西的判断。同时，保持初心者的心态，去除内心的干扰，营造安静纯粹的环境，让灵感和创意在内心自然而然地流动。我们只是记录者，而非创造者，我们真正的工作是全然地在场、清醒地感受，让艺术不可避免地通过我们呈现出来。

我想，创作的场，需要一种悖论式的修行 —— 既要努力吸收、打磨技艺、塑造品味，又要放下 “我必须写出好东西” 的执念；既要保持敏感，让天线始终竖起，又不能在信号来临时用力过猛，把那个脆弱的频率吓跑。就像握一只鸟，太紧会捏死，太松会飞走。那个刚刚好的力度，叫做 “放松的专注 ”

这也许就是为什么许多创作者在洗澡时、散步时、半梦半醒时最容易冒出好想法 —— 因为那些时刻，你既在场，又不在场。身体在做着不需要动脑的事，意识处于半开放的状态，那个 “日常堆积阻塞的思想状态” 暂时退场，于是宇宙的信号有了可乘之隙。你不请它来，它反而自己来了

所以，如果你也想进入那个场，不妨可以试试这样做：

当你开始动笔时，允许自己写得很烂。允许废话连篇，允许逻辑混乱，允许词不达意。因为只有当你不再害怕写烂东西的时候，好东西才会悄悄溜进来。初稿的烂，是通往好作品的唯一道路。

当你卡住的时候，不要硬闯，也不要放弃。放下笔，去走路，去喝水，去看云。让潜意识继续工作，让那个卡住的部分自己松动。很多时候，答案不是想出来的，而是等出来的。

当你终于写完一个作品，哪怕不完美，也要把它当作一个完整的生命来对待。它诞生了，它有它自己的样子。你可以以后修改它、打磨它，但此刻，请允许它存在。

最重要的是：持续地在那里。不是等灵感来了才去写，而是每天都去那个场里坐一会儿。像园丁每天去看他的花园，即使冬天没有花开，他也知道泥土下面有根在呼吸。你越是在场，那个场就越熟悉你，就越愿意接纳你

所以，去吧。去成为那个灵感愿意降临的地方。去写、去画、去唱、去做，去在场

关于人性

性本善？性本恶？

人性本善，还是本恶？这个问题争论了几千年

孟子说性善，荀子说性恶，告子说性无善恶。我越来越倾向于告子的观点：“人性之无分于善不善也，犹水之无分于东西也。” 人性就像流水，你在东方挖开它就向东流，在西方挖开它就向西流。水本身没有方向，是地势决定了它的流向；人本身没有固定的善恶，是环境塑造了他的选择

同样的水，可以灌溉良田，也可以吞噬生命；可以清澈如镜，也可以污浊不堪。水还是那个水，只是流经的地方不同。人也如此 —— 那个在和平年代温文尔雅的人，放在另一套环境里，会不会变成另一个人？这个问题，细思极恐

最极端的例子是饥荒。历史上，每逢大饥荒，总有 “人吃人” 的记载。明末清初的《甲申纪事》里写道：“人相食，骨肉相食，易子而食。”这不是那些人天生残忍，而是极端环境把生存本能推到了极致。当一个人饿到皮包骨头，眼窝深陷，眼前只有死人和快要饿死的孩子时，他的行为已经不能用正常的道德来衡量了。道德是饱腹者的奢侈品，是安定社会的产物。把任何一个人放在那样的境地里，谁能保证自己不会变成野兽？

电影《一九四二》里有这样一个场景：灾民为了活命，卖儿卖女，甚至交换孩子煮食。弹幕里有人骂 “残忍”，有人刷 “人性本恶”。但真正值得问的是：如果把你放在 1942 年的河南，饿到啃树皮、吃泥土，眼看最后一个孩子奄奄一息，你会做什么？我们不是那些人，只是因为我们没有活在那个场里

那个著名的实验，Stanfordprisonexperiment，也在告诉我们：场是如何把普通人塑造成恶魔的。1971 年，心理学家津巴多把一群健康的大学生随机分成狱警和囚犯，放在模拟监狱里。原本计划进行两周的实验，六天后就被迫终止 —— 因为那些学生完全被环境吞噬了。扮演狱警的变得残暴，开始侮辱囚犯，强迫他们做俯卧撑、脱光衣服；扮演囚犯的变得抑郁、崩溃，有人甚至出现心理应激反应；仅仅六天，短短六天，一群普通人就变成了施虐者和受虐者。津巴多后来写了一本书叫《路西法效应》，副标题是 “好人是如何变成恶魔的”。他得出的结论是：情境的力量足以让最普通的人变得残暴或顺从，只要给他合适的角色、规则和环境

无独有偶，在纳粹集中营许多幸存者的回忆录里都提到：有些囚犯变成了 “Kapo”（集中营里的囚犯监工），他们对同胞的残暴程度甚至超过了纳粹。这不是他们天生冷酷，而是那个极端环境让他们相信：只有变得比敌人更狠，才能活下来。环境重塑了他们的价值排序，生存取代了一切

但同样是在二战期间，也有另一种人。许多普通人冒着生命危险藏匿犹太人，他们被称为 “国际义人”。研究这些人的心理时发现，他们并没有比其他人更勇敢或更高尚，但他们往往成长在一个重视正义、同情弱者的家庭或社区里。有人回忆说 “父母从小就告诉我，每个人都有尊严，哪怕是陌生人。” 那个场，让他们在关键时刻听到了另一个声音 —— 不是 “这很危险”，而是 “这是对的事”。当大多数人选择沉默时，他们选择开门，不是因为他们天生是英雄，而是因为他们浸泡过的场让那扇门更容易被推开

这就是环境的魔力。它不是在你做选择时替你决定，而是在你做选择之前，就已经悄悄改变了你的判断标准。你每天接触的人、反复听到的言论、习以为常的氛围，都在一点一点塑造你的 “正常”。当你身边的人都在作弊，诚实就显得愚蠢；当你身边的人都在行善，冷漠就显得可耻。你不是在善恶之间做选择，你只是在顺应你的场

当然，同样的场也不会把每个人铸造成同一个模样。有人在恶劣环境里沉沦，也有人因此更早学会警惕与抵抗；有人在善意里生长，也有人因旧伤而迟迟不敢信任。气质、记忆、教育、偶然的相遇，都会让同一个场在不同人身上长出不同结果。环境强大，但并非全能

激发善意

所以，与其争论人性本善还是本恶，不如思考：如何把自己置于一个能激发善意的环境中

如果我们借用芒格的反向思维方式，想明白怎样才能幸福，先想清楚什么会让人不幸；想明白怎样才能善良，先想清楚什么会让人作恶。按照这个思路，我们要避免的是把自己放到那些会激发恶意的环境里 —— 比如资源极度匮乏的地方，比如没有规则约束的真空，比如权力完全失衡的关系。这些场，会一点点磨掉你身上的善意，把你变成自己都不认识的人

然后，才是更积极的那一步：让自己更多地 “与善人居”。你选择的朋友圈、你每天浏览的信息、你生活的社区、你沉浸的文化产品，都在悄悄改变你 —— 当你身边的朋友都在读书，你也会不自觉地拿起书；当你关注的内容创作者都在输出真诚和思考，你也会慢慢学会辨别什么是好东西；当你生活的社区里有人需要帮助时总有人伸手，你也会在下一次看到类似场景时，多犹豫一秒，然后选择帮忙。那些微小的、重复的、习以为常的瞬间，就是场在塑造你

反过来也一样。当你身边的人都习惯了抱怨，你也会觉得世界本来就该这样；当你刷到的内容都在制造焦虑，你也会觉得自己活得很失败；当你生活的环境里人人自扫门前雪，你也会在下一次看到需要帮助的人时，告诉自己 “多一事不如少一事”。你没有变，你只是在顺应那个场

所以，选择自己的场，就是选择自己的人性走向。不是因为你软弱，而是因为你清醒 —— 清醒地知道自己会被环境塑造，清醒地知道自己想要成为什么样的人，然后主动把自己放进那个能让你成为那种人的地方

人性是一汪水，它没有固定的形状，却会被容器塑造。选一个好的容器，不是为了显得高尚，而是为了让那水流过你一生的时候，清澈一点，温柔一点

选择自己的场

写到这里，回头看这些散落在工作、生活、创作、人性中的碎片，忽然发现它们其实都在说同一件事：我们比自己想象中更脆弱，也比自己想象中更自由

脆弱的是，我们无法逃脱环境的浸润。无论是办公室的考核机制，还是原生家庭的呼吸节奏；无论是亲密关系里的日常摩擦，还是深夜独坐时那忽明忽灭的灵感 —— 这些 “场” 都在无声地塑造着我们，像河水雕刻河床，像风塑造沙丘。你以为自己在做选择，其实很多时候，你只是在顺应那个场给出的选项

但自由的是，我们终究可以选择把自己放在哪个场里

这才是 “孟母三迁” 背后真正的智慧。孟母不是逃避，而是主动选择 —— 她知道那个场会塑造她的孩子，所以她愿意一次次搬家，哪怕麻烦，哪怕未知。这种决断力，本质上是一种清醒：清醒地意识到自己正在被什么塑造，清醒地知道自己要去向哪里，然后拿出行动，把自己放进那个对的场里。这不是矫情，这是对自己生命最大的负责

Naval Ravikant 曾指出人生的三个重大决定：
1. Where you live
2. Who you’re with
3. What you do

这三个决定，本质上就是在为你的人生挑选宏大的 “场”。选对了场，你的人生就是顺流而下，每一次努力都会被环境放大，每一次成长都会得到正反馈；选错了场，你终其一生都在与无形的阻力搏斗，像逆流而上的鱼，耗尽力气却只在原地打转

在哪里生活，决定了你每天呼吸的空气、看见的风景、遇见的陌生人。城市有城市的场，乡村有乡村的场；北上广有北上广的节奏，小城有小城的呼吸。没有绝对的好坏，只有是否适合你。有些人只有在喧嚣中才能生长，有些人只在安静里才能开花。你要诚实地问自己：我在哪里，能成为更好的自己？

和谁在一起，决定了你最亲近的那些人如何与你对话、如何对待你的脆弱、如何在深夜给你回应。伴侣、朋友、同事 —— 他们是你日常浸泡的场，是你会被无声同化的方向。选对人，你会在爱里变得柔软而坚定；选错人，你会在消耗中一点点枯萎

从事什么工作，决定了你每天醒来的八个小时被什么占据。是创造还是重复？是意义感还是空虚？是向上生长还是原地打转？工作不只是谋生，它是你与这个世界发生连接的方式，是你把自己交付出去的那个场

这三个决定，听起来宏大，其实都落实在一次次具体的选择里：是接受那份高薪但不快乐的工作，还是赌一把去做自己真正热爱的事？是留在一段消耗你的关系里，还是独自面对未知的孤独？是留在熟悉但窒息的城市，还是去一个陌生但有光的地方？

没有人能替你选。甚至选了之后，也没有人能保证结果。但有一件事是确定的：你永远可以选择离开一个不适合的场，永远可以选择走向一个可能更好的场。这不是逃避，而是对自己的诚实。每一次离开，都是一次 “迁”；每一次 “迁”，都是一次对自己说：我值得更好的

孟母三迁，迁的不是地方，是孩子的未来。我们这一生，其实也是在不断地 “迁”—— 从一个场走向另一个场，从被塑造走向主动塑造，从 “我是环境的产物” 走向 “我仍可以作出自己的选择”。这个过程没有终点，你永远在途中。但也正是这种 “永远在途中”，让你始终保有改变的可能

所以，在结束这篇漫长的碎碎念之前，我想对你说 —— 也是对我自己说：

愿你在工作中找到那个让你愿意早起的场。不是被闹钟叫醒，而是被想做的事情叫醒。在那里，你的每一次努力都看得见回响，你的每一次创造都有人看见

愿你在生活里找到那个让你安心的场。哪怕外面风雨再大，回去的地方有一盏灯、一个人、一个可以卸下所有伪装的空间。在那里，你可以脆弱，可以失败，可以不用解释

愿你在创作中找到那个让灵感降临的场。不用苦苦追逐，不用焦虑等待，只是安静地在那里，像土壤等待种子，像深夜等待黎明。当信号来临时，你有足够的敏感接住它

愿你的人性之水，流经的皆是芝兰之室。不是因为世界本就美好，而是因为你主动选择了那些让美好更容易发生的地方

选对场，然后顺流而下

剩下的，交给时间

From Bid Shading to Score Shading: Modeling, Control, and Game Dynamics in Mixed Ranking Optimization

2026-01-26T00:51:23.000Z

In Ad Network scenarios, multiple DSPs (Demand Side Platforms)participate in auctions, typically under a First Price Auction (FPA)mechanism. To optimize performance, DSPs often employ BidShading techniques to maximize their ROI and revenue whilemaintaining a competitive level of inventory acquisition.

Bid Shading is a specialized technique developed for first-priceauctions. Since the final clearing price equals the submitted bid (i.e.,pay-as-you-bid), bidding one’s true valuation often leads to “winner’scurse” or overpayment, resulting in capital inefficiency. Consequently,Bid Shading leverages historical data to estimate win rates or the“market price” (the second-highest bid) to dynamically shade the bid.This ensures the final payment is lower than the original valuation buthigher than the second-highest bid, effectively reducing costs andboosting ROI without sacrificing win probability.

In feed mixed ranking (MixRank) scenarios, various business lines(such as Ads, E-commerce, Live Streaming, Short Video, and Articles)provide a “PK Score” for ranking during each request. From a mechanismstandpoint, this PK Score is functionally equivalent to a bid in anadvertising system: the PK Score can be viewed as an “implicitbid” submitted by a business entity for an exposureopportunity.

Naturally, this raises a question: Can we adapt the principles of BidShading to systematically calibrate PK Scores and optimize overall mixedranking utility? Theoretically, this is highly feasible. This articleintroduces Score Shading—a method of applying dynamicperturbations (shading) to PK Scores to identify the globally optimal“bidding point.” By doing so, the system maintains competitiveness whilemaximizing platform-wide revenue, specifically addressing two coreobjectives:

Problem One: Enhancing the penetration rate (loadgrowth) of specific content formats in high-value traffic by increasingtheir “participation-to-exposure” ratio.
Problem Two: Reducing the scale (i.e., the cost) of aspecific format’s PK Score while keeping the overall win rate (load)stable and within a reasonable range.

This article will first review Bid Shading modeling in Ad Networks,then generalize it to mixed ranking Score Shading. We will exploreoptimization modeling for both objectives, the Lagrangian dual solution,and the regulation mechanism for the pacing parameter λ. Finally, wewill discuss critical challenges such as win-rate modeling and incentivecompatibility.

Bid Shading Methodology

From the perspective of a DSP in an Ad Network, the Bid Shadingproblem is typically modeled as the following optimization task:maximizing value (cost) subject to a target profit margin constraint (1- media payout / revenue).

\[\begin{aligned}\max_{x_i} \quad & \sum_{i} C_i F(x_i) \\\text{s.t.} \quad & \sum_{i} x_i F(x_i) \le K \sum_{i} C_i F(x_i)\end{aligned}\]

The notation is defined as follows:

$C_i$: The intrinsic value of the$i$-th traffic unit (usuallysynonymous with valuation in Ad Networks).
$x_i$: The bid price submitted bythe DSP for the current request.
$F(x_i)$: The win rate(probability of winning) given bid $x_i$.
$K$: The target profit marginconstraint.

Using the method of Lagrange multipliers, we construct the followingLagrangian, where $\lambda$ is themultiplier ($\lambda > 0$):

\[\mathcal{L}(x_i, \lambda) = \sum_i C_iF(x_i) - \lambda \left[ \sum_i x_i F(x_i) - K \sum_i C_i F(x_i)\right]\]

Rearranging the terms yields:

\[\mathcal{L}(x_i, \lambda) = \sum_iF(x_i) \left[ (1 + \lambda K)C_i - \lambda x_i \right]\]

The role of $\lambda$ is to ensurethe constraint is satisfied. In production environments, $\lambda$ is often adjusted dynamically viaa controller (such as a PID) to ensure the actual profit rate (TAC)aligns with expectations. However, within a specific time slice, $\lambda$ remains constant. Thus, for eachonline request, the system selects the optimal bid $x_i^*$ that maximizes the Lagrangian $\mathcal{L}$:

\[x_i^*=\arg\max_{x_i}\;F(x_i)\left[(1+\lambda K)C_i - \lambdax_i\right]\]

How should $\lambda$ be regulated?We can further reformulate the objective as follows:

\[\mathcal{L} = \sum_i \cdot F(x_i)\left[C_i + \lambda(KC_i-x_i) \right]\]

If the actual TAC exceeds the target $K$ (i.e., DSP profit is belowexpectations), $\lambda$ isincreased. In this state, choosing an excessively high bid $x_i$ would penalize $\mathcal{L}$, forcing the system tonaturally select a lower bid $x_i$ torestore the profit margin. Conversely, $\lambda$ is decreased to enhance the DSP’scompetitiveness and volume acquisition.

Score Shading Strategy

In mixed ranking, each business line’s PK Score can be treated as itsbid for a given request. Building upon the Bid Shading paradigm, we canmodel the following scenarios. First, we define several corevariables:

$V$: The value term—the businessutility gained if a specific format wins the exposure, defined by thebusiness entity.
$s$: The PK Score, which servesas the “cost” or “shadow price” for winning the auction.
$F(s)$: The win rate model,representing the probability of winning given a score $s$.
$C$: The business cost constraint(often a proxy for long-term user value like LT, which is difficult tooptimize directly).

Using these symbols, we model the following two problemsrespectively:
- Problem One: On high-value traffic, increase the conversion ofspecific formats from “not shown” to “shown,” boosting formatpenetration (load growth).
- Problem Two: While maintaining a stable overall win rate (load),reduce the scale or cost of a format’s PK Score to keep it within anefficient range.

Problem One: ImprovingPenetration

This objective is defined as maximizing the expected utility of eachauction while ensuring the aggregate cost (PK Score) remains within aspecified budget or constraint.

\[\begin{aligned}\max_{s_i} \quad& \sum_{i=1}^{n} V_i F(s_i) \\\text{s.t.} \quad& \frac{1}{n}\sum_{i=1}^{n} s_i F(s_i) \le C\end{aligned}\]

The critical challenge here is defining the constraint $C$. While Long-Term Value (LTV/LT) is thefundamental constraint, its long feedback loop and high volatility makeit unsuitable for real-time control.

Furthermore, since mixed ranking systems often impose limits on thedistribution of PK Scores (e.g., ensuring p90 or p99 values remaincomparable across business lines), we use the winning PK Score as thedirect constraint. Theoretically, mean, P90, and P99 each requireindividual constraints, but for simplicity, we model the mean constrainthere.

Using the Lagrangian dual approach, we derive the followingfunction:

\[\mathcal{L}(s_i,\lambda)=\sum_{i=1}^{n}V_i F(s_i) - \lambda \left(\sum_{i=1}^{n} s_i F(s_i) -nC\right)\]

Rearranging gives:

\[\mathcal{L}=\sum_{i=1}^{n} F(s_i)\left(V_i - \lambda s_i\right)+ \lambda nC\]

Since $C$ is constant, it can beomitted. For the $i$-th request, wesimply choose $s_i^*$ to maximize thefollowing objective, where $\lambda$acts as the pacing coefficient to keep the average PK Score withinbounds (multiple constraints would imply multiple $\lambda$ values):

\[s_i^*=\arg\max_{s_i}\;F(s_i)\left[(V_i -\lambda s_i) \right]\]

Problem Two: Cost Reduction

In this scenario, the goal is to minimize the PK Score while keepingthe business utility constant. The problem is formalized as follows,where we minimize the PK Score (mean) subject to a win rate constraint$T$ (a proxy for load).

\[\begin{aligned}\min_{s_i} \quad& \frac{1}{n}\sum_{i=1}^{n} s_i F(s_i) \\\text{s.t.} \quad& \frac{1}{n}\sum_{i=1}^{n} F(s_i) = T\end{aligned}\]

Through Lagrangian derivation, we obtain the dual function:

\[\mathcal{L}(s_i,\lambda)=\frac{1}{n}\sum_{i=1}^{n}s_i F(s_i)+\lambda \left(\sum_{i=1}^{n} F(s_i) - nT \right)\]

The decision goal is to select $s_i^*$ for each request that minimizes thefollowing, where $\lambda$ is thepacing coefficient for the win rate:

\[s_i^* = \arg\min_{s_i}\;F(s_i) \cdot\left(s_i - \lambda\right)\]

Here, $\lambda$ effectivelyfunctions as the “marginal value of a win” or a “price threshold.”Analyzing $F(s_i) \cdot (s_i -\lambda)$, two cases arise:

If the traffic is “cheap” ($s_i <\lambda$): The term $(s_i -\lambda)$ is negative. To minimize this (make it more negative),we want $F(s_i)$ to be as large aspossible—i.e., bid higher to win the “bargain.”
If the traffic is “expensive” ($s_i >\lambda$): The term $(s_i -\lambda)$ is positive. To minimize this, we want $F(s_i)$ to be as small as possible(approaching 0)—i.e., bid lower or abstain from the “loss-making”auction.

In practice, $\lambda$ is alsodynamically tuned via a PID controller. If volume is insufficient ($T$ is not reached), $\lambda$ is increased; if volume exceedsthe target, $\lambda$ isdecreased.

Key Technical Challenges

Q1: Win-Rate Modeling

Accurately modeling the win rate $F(s)$ is the most critical component ofthis framework.

The most straightforward approach is to directly model thewin probability given a bid, which can be implemented in twoways:

Method One: Log Replay. Construct pairs from historical logs and train a binaryclassifier (similar to a CTR model). However, this requires carefulhandling to ensure $F(s)$ remainsmonotonic with respect to $s$.
Method Two: Curve Fitting. Perform parametric or non-parametricregression on historical statistics to better guarantee the monotonicityof $F(s)$.

A more sophisticated approach is DistributionEstimation—instead of modeling the win probability directly, wemodel the probability distribution of the highest competing score in theauction, similar to the DeepLandscape Forecasting (DLF) method.

The core difference is that the former is Point Estimation,while the latter is Distribution Estimation. Point estimationonly provides $\mathbb{P}(\text{win}=1 | s,\text{context})$. To determine “how the win rate changes if Ibid $s + 0.1$,” the model must re-runinference, which is computationally expensive. More importantly, itcannot capture the uncertainty of the competitiveintensity.

And methods like Deep Landscape Forecasting predict the probabilitydistribution parameters of the opponent’s highest score (assuming it isa Gaussian distribution, with parameters $\mu, \sigma$). Once the distributionfunction is available, you can directly get the win rate under any bidthrough $F(s) = \Phi(s; \mu,\sigma)$.

And in this, $\sigma$ (variance)has a clear physical meaning: it represents the uncertainty ofthe current request competition. If the user-side historicalfeatures show that this user often watches live streaming (intense andunstable competition), $\sigma$ willbecome larger. In the dual optimization logic, a large $\sigma$ will automatically trigger“conservative bidding,” preventing volume loss caused by predictionbias.

For the point estimation modeling method, “almost winning (opponentscore 1.01, you bid 1.0)” and “miserable defeat (opponent score 5.0, youbid 1.0)” are the same in the eyes of the model, but they can both bemodeled in distribution estimation. This also makes distributionestimation characterize the “competition landscape” far more accuratelythan binary models, especially when you try to lower scores throughShading, DLF can more accurately tell you “to what extent lowering willencounter the dense area of competitors.”

Therefore, in the following situations, the necessity of modelingdistribution methods like DLF will be relatively strong:

1) Highly uneven score distributions: If competitorscores cluster heavily under specific features (e.g., evening peaks),DLF’s descriptive power helps avoid “red ocean” competition.
2) High sensitivity to volume loss: If undershootingthe load target due to aggressive shading is unacceptable, DLF’svariance $\sigma$ provides a “safetymargin” that binary models cannot.
3) Compute constraints: If you cannot affordmulti-point sampling online, the “infer once, solve analytically” natureof DLF is the only viable choice.

Regarding DLF implementation, refer to Deep Landscape Forecasting forReal-time Bidding Advertising. Key technical points include:

The core of DLF lies in not directly modeling the win rate, butmodeling the probability distribution $P(Z|\theta)$ of the opponent’s highestscore $Z$. Suppose $Z$ follows a log-normal distribution(Log-Normal), and the model outputs parameters $\theta = (\mu, \sigma)$. The modelingdetails are as follows:

1. Core Definitions

Probability Density Function (PDF) $f(z |\theta)$: The probability that the highest competing bid isexactly $z$.
Cumulative Distribution Function (CDF) $F(s | \theta) = P(Z < s)$: The win rateat bid $s$.
Survival Function $S(s | \theta) = 1 -F(s | \theta) = P(Z > s)$: The probability that bid $s$ fails to win.

2. Loss Function Derivation

In training, samples are typically Right-Censored—after aloss, we only know $Z \ge s$. DLFutilizes a Negative Log-Likelihood (NLL) loss:

\[\text{Loss} = \sum_{i \in \text{win}}\underbrace{-\log f(Z_i | \theta_i)}_{\text{Regression on observedsecond-prices}} + \sum_{i \in \text{loss}} \underbrace{-\log S(s_i |\theta_i)}_{\text{Constraint on censored/lost bids}}\]

For winners: We observe the true highest competing score $Z_i$ (the second price) and minimize theresidual via the PDF.
For losers: We only know $Z_i >s_i$. The survival function term forces the model to learn thatthe opponent’s distribution is concentrated above the current bid.

3. Online Analytical Decision-Making

Since $F(s)$ is parameterized as aknown distribution (e.g., $\Phi$), wecan solve for $s_i^*$ analytically.For Problem One, the optimal $s$ isfound by taking the first derivative and setting it to zero:

\[\frac{\partial}{\partial s} [F(s)(V -\lambda s)] = 0\]

Simplifying yields:

\[F'(s) \cdot (V - \lambda s) -\lambda F(s) = 0 \implies \frac{F(s)}{F'(s)} + s =\frac{V}{\lambda}\]

The elegance of DLF lies in the fact that $F(s)$ and $F'(s)$ are no longer black boxes butconcrete formulas with parameters $\mu,\sigma$. For a Log-Normal distribution:

$\Phi$ (CDF): $F(s) = \Phi(\frac{\ln s -\mu}{\sigma})$

$\phi$ (PDF): $F'(s) = \frac{1}{s\sigma} \phi(\frac{\ln s -\mu}{\sigma})$

This eliminates the need for expensive discrete sampling or gridsearches online, allowing the system to locate the optimal shaded scorein microseconds.

Q2: Feedback Loop Mitigation

When Score Shading is active, the observed “win rate” is based onalready-reduced scores. As bids decrease, the competitive landscapeappears “harder to win,” causing $F(s)$ to downgrade further—leading to a“death spiral” of plummeting bids.

The standard solution is an Epsilon-Greedy exploration mechanism:allocating a small percentage of traffic to an “exploration bucket”where scores remain unshaded. This provides the ground truth needed tocollect unbiased competition data.

Systemic Risks

From a single business line’s perspective, Score Shading is a perfectlocal optimizer. However, from a platform-wide perspective, if everybusiness line shades independently, it triggers a game-theoretic “raceto the bottom,” potentially destabilizing the entire distributionecosystem.

Potential Pitfalls

If the platform allows every format (Short Video, Articles,E-commerce, Live Streaming) to run independent PID controllers for ScoreShading, several issues arise:

(1) Score Deflation and the “Broken Window” Effect (Race tothe Bottom) Suppose Articles and Live Streaming compete for thesame slot. Live Streaming shades its score from 1.0 to 0.8. Articles,seeing weaker competition, shades its score from 0.9 to 0.7 to win. LiveStreaming then finds it can still win at 0.6…

This leads to a severe leftward shift (deflation) of the globalranking scores (MixRank Score). Many platforms have hard“experience protection thresholds” (e.g., filtering content with Score< 0.3). Score deflation can cause high-quality content to fall belowthese absolute thresholds, resulting in “empty slots” (frontend gaps) ora flood of low-quality fallback content.

(2) Oscillatory Instability via Multi-PID Coupling(Oscillation & Chaos) In mixed ranking, traffic is often azero-sum game. When Live Streaming’s $\lambda_1$ and Short Video’s $\lambda_2$ controllers act on the sametraffic pool, they form a complex non-linear coupling. If Live Streamingslightly increases its score, Short Video’s volume (Load) instantlydrops, triggering a violent compensatory reaction (score spike) from theShort Video PID.

This results in high-frequency, pulse-like oscillations inonline traffic distribution—where the feed might be entirely LiveStreaming one minute and entirely Short Video the next. This instabilitydestroys user experience and creates “compute tides” that can overloadbackend servers.

Governance Strategies

To mitigate these systemic issues, two primary strategies exist:establishing a global “Score Anchor” or implementing a unifiedauction mechanism (e.g., VCG) to internalize externalities.

Solution One: The “Global Anchor” Strategy

Without an anchor, Score Shading is like countries engaging incurrency wars. Since the auction is “relative,” absolute scores cancollapse infinitely. An anchor acts as the “Gold Standard” or “USD”of the mixed ranking economy. The platform mandates that adominant core format (e.g., organic recommendation for Short Videos orArticles, accounting for >70% of traffic) is strictly prohibited fromshading. Its score must 100% honestly reflect its estimated businessvalue (True Value). Alternatively, Ads can serve as an anchor as theireCPM has a clear physical meaning and is less prone to abruptshifts.

By fixing this anchor, all other formats (Live, E-commerce) have a“physical floor” for their shading behavior. If they shade below theanchor’s true value, they immediately lose volume. This creates a PriceFloor that prevents systemic collapse and the “race to the bottom.”

Solution Two: Unified Auction Mechanism (VCG) forAccounting

Although VCGis typically an ad-tech concept, it can be applied to all business linesto account for the “opportunity cost” one format imposes on theplatform. This effectively eliminates the incentive for shading.

The core logic of the VCG mechanism is: business lines nolonger pay according to their own “bid,” but pay according to the“social cost” they cause to the system. In other words, if youwin, you pay for the value lost by those you displaced.

Specifically, if Business A wins a slot, the “price” it pays equals:“the total value other participants would have gained if A wereabsent” minus “the total value other participants gain when A ispresent.” For example:

Suppose there are 3 slots. With A, the optimal set is {A, B, C} withtotal value $W = V_A + V_B + V_C$.The steps for VCG pricing are:

Calculate total value $W$.
Simulate the system “without A.” A new business D enters, and theset becomes {B, C, D}.
A is charged the “Score Cost” $P_A =(V_B^{new} + V_C^{new} + V_D) - (V_B^{old} + V_C^{old})$.

VCG is the gold standard for achieving IncentiveCompatibility. In an incentive-compatible system, “tellingthe truth” (truthful bidding) is the dominant strategy—any attempt toshade or manipulate scores will harm the participant’s own interests.VCG aligns individual and platform interests perfectly:

If Business A overbids (Positive Shading), its cost is determined bythose behind it. If its true value is lower than the clearing price, itincurs a loss.
If Business A underbids (Negative Shading), it only reduces itschance of winning without reducing the cost it pays when it does win(since its price is independent of its own bid).

Under VCG, business lines realize that shading yields no extrabenefit, and only truthful reporting of estimated value maximizes theirsurplus.

However, despite being mathematically perfect, VCG faces massiveimplementation hurdles in production.

First is Computational Complexity. VCG requiressimulating the “counterfactual” for every winner. For $N$ slots, this theoretically requires$N+1$ full ranking passes. Inhigh-performance recommendation engines, this latency is oftenprohibitive.

Second is Metric Alignment. VCG assumes $V_B + V_C$ is additive. But is 1 minute ofLive Stream duration truly equivalent to 1 minute of Short Videoduration? When Ads (eCPM) and E-commerce (GMV) are added, the units areinherently misaligned. If the global value function $f(V)$ is poorly defined, VCG will generatemisleading charges, causing the ecosystem to tilt dangerously toward oneformat and collapse.

Consequently, VCG is typically reserved for highly refined stages ofplatform growth where absolute fairness is the priority. In earlierstages, Solution One (Global Anchor) is usually preferred for itssimplicity and agility.

Summary

This article explores the transition of Bid Shading from theadvertising domain to the feed mixed ranking landscape—Score Shading. Bytreating PK Scores as “implicit bids,” we bridge the gap between auctiontheory and recommendation algorithms, providing a rigorous mathematicalframework for format penetration and scale control.

The success of Score Shading rests on three pillars:

Dual Optimization Framework: Using LagrangianDuality to transform global business constraints into real-timedecisions via PID-controlled $\lambda$.
Win-Rate Modeling: Moving beyond binary pointestimation to Distribution Estimation (DLF), allowing the system to mapthe “competitive landscape” and solve for optimal bids analytically andefficiently.
Systemic Governance: Guarding against scoredeflation and oscillations through Global Anchors or VCG-based incentivecompatibility to align individual format goals with platform-widehealth.

As mixed ranking systems evolve, simple value comparisons are beingreplaced by sophisticated mechanism design. Score Shading is not just atuning trick; it is a manifestation of platform governance throughmathematical modeling. Future efforts will likely incorporateReinforcement Learning (RL) to manage even longer-cycle constraints,such as long-term retention (LT), ensuring fairness and growth across acomplex multi-format ecosystem.

从 Bid Shading 到 Score Shading：混排优化的建模、控制与博弈

2026-01-26T00:51:23.000Z

在网盟广告（Ad Network）场景中，会有多个 DSP（Demand SidePlatform）共同参与竞价，且通常采用一价拍卖（First Price Auction,FPA）的计费方式。此时 DSP 往往会通过 Bid shading技术，在保证一定获量能力的前提下，最大化自身的 ROI 和收入

Bid shading是一种在一价拍卖中衍生出来的技术，因为广告主最终支付的价格等于其出价（即按出价付费），直接提交真实估价往往会导致超额支付，造成成本浪费。所以Bid shading基于历史数据预估竞胜率或第二高价，动态调整出价，使得最终支付金额低于原始出价，但高于第二高价，从而在维持竞胜率的同时降低成本、提升ROI

而在信息流混排场景中，各业务方（如广告、电商、直播、短视频、图文等）在每次请求中都会给出一个PK 分用于排序分。从机制角度看，这个 PK 分其实与广告系统中的 bid非常类似：PK分可以被看作是业务方对曝光机会的一种 “隐式出价”

因此，一个自然的问题是：是否可以借鉴 Bid Shading 的思想，对 PK分进行系统化调节，从而优化整体混排收益？原理上自然是可行的，本文将其称为Score Shading 方法，即对 PK分进行类似的动态扰动（Shading），在保持竞争力的前提下，寻找全局最优的 “报价点”，以达到整体业务收益最大化的目标。期望解决以下两个核心问题：

问题一：在高价值流量上，提高某种体裁从 “不出” 到 “出” 的比例，提升这种体裁的渗透率（load增长）
问题二：在保持整体竞胜率（load）不变的前提下，降低某种体裁的PK 分量纲（即成本），使其保持在合理范围内

本文将首先回顾网盟场景下的 Bid shading 建模方法，然后将其推广至混排Score shading，并详细讨论两种目标下的优化建模、拉格朗日对偶解法以及 λ的调控机制。最后对竞胜率建模、激励兼容性等关键问题展开讨论

Bid Shading 做法

在网盟场景下的 DSP 视角，Bid shading问题往往可以建模为如下的最优化问题, 最大化的目标是 cost,约束是利润率（1 - 媒体分成 / 收入）

\[\begin{aligned}\max_{x_i} \quad & \sum_{i} C_i F(x_i) \\\text{s.t.} \quad & \sum_{i} x_i F(x_i) \le K \sum_{i} C_i F(x_i)\end{aligned}\]

各符号含义如下

$C_i$：第 $i$ 条流量的价值（在网盟的场景下一般是cost）
$x_i$：dsp 在当前流量的报价
$F(x_i)$: 在 $x_i$ 报价下的竞胜率
$K$：利润率约束

通过拉格朗日乘数法可构造如下拉格朗日系数，其中 $\lambda$ 是拉格朗日乘子 ( $\lambda >0$)

\[\mathcal{L}(x_i, \lambda) = \sum_i C_iF(x_i) - \lambda \left[ \sum_i x_i F(x_i) - K \sum_i C_i F(x_i)\right]\]

整理公式可得

\[\mathcal{L}(x_i, \lambda) = \sum_iF(x_i) \left[ (1 + \lambda K)C_i - \lambda x_i \right]\]

$\lambda$的作用是为了让约束达成，在实际中往往会通过控制器（如PID）来动态调控利润率即 TAC 满足预期。但在一个时间片内，$\lambda$的值是固定的，因此线上对每条请求实际生效的时候，就是选择一个最优的 $x_i^*$ 使得上面的 $\mathcal{L}$ 最大化，即

\[x_i^*=\arg\max_{x_i}\;F(x_i)\left[(1+\lambda K)C_i - \lambdax_i\right]\]

那 $\lambda$ 应该如何调控？我们可以对上面的公式进一步整理成如下形式

\[\mathcal{L} = \sum_i \cdot F(x_i)\left[C_i + \lambda(KC_i-x_i) \right]\]

则当实际的 tac 高于设定的目标 K 时（dsp 利润不达预期），调大 $\lambda$，此时如果选择一个很大的对外报价$x_i$, 会让 $\mathcal{L}$的值变小甚至为负，因此会自然选择一个小的对外报价 $x_i$，提高这一次请求的利润率。反之会调小$\lambda$ 提高 dsp 拿量的能力

Score Shading 方案

如同在混排中，每个业务方在请求中的 PK分也可被认为是对这次请求的出价，基于上面 bid shading的建模范式，也可以分别对下面的问题做建模。但在此前，有几个通用关键变量需要定义

$V$：价值项，即在混排中某种体裁胜出后的业务价值，需要由业务自定义
$s$：混排的 PK分，可以近似作为混排中获胜需要付出的成本
$F(s)$: 竞胜率模型，在 PK 分$s$ 下的竞胜率
$C$: 业务成本的约束（一般是LT，但实际中往往难以直接应用，所以一般需要找代理指标）

基于上述符号，我们尝试对以下两个问题分别做建模
-问题一：在高价值流量上，提高某种体裁从 “不出” 到 “出” 的比例，提升这种体裁的渗透率（load增长）
- 问题二：在保持整体竞胜率（load）不变的前提下，降低某种体裁的 PK分的量纲 / 成本，使其保持在合理范围内

问题一：提升渗透

这个问题定义比较清晰，就是最大化每次竞价的收益期望，同时保证成本（PK分）在约束范围内

\[\begin{aligned}\max_{s_i} \quad& \sum_{i=1}^{n} V_i F(s_i) \\\text{s.t.} \quad& \frac{1}{n}\sum_{i=1}^{n} s_i F(s_i) \le C\end{aligned}\]

上面建模比较关键的问题是约束 $C$的定义，从业务本质上来讲，LT是最根本和最核心的约束，但由于观测周期长，短期波动性较大，不适合作为直接的约束指标

同时，由于大混排业务中对各个业务方的 PK 分往往有直接约束（如 PK 分的p90、p99 分位相较于其他业务不能过大），因此这里直接考虑将竞胜的 PK分作为约束；理论上均值、P90、P99都需要一个单独的约束，这里就只写了均值作为约束

同样使用上面的拉格朗日对偶建模方式，可得到拉格朗日函数形式如下

\[\mathcal{L}(s_i,\lambda)=\sum_{i=1}^{n}V_i F(s_i) - \lambda \left(\sum_{i=1}^{n} s_i F(s_i) -nC\right)\]

整理可得，

\[\mathcal{L}=\sum_{i=1}^{n} F(s_i)\left(V_i - \lambda s_i\right)+ \lambda nC\]

由于 $C$ 是常数，可以忽略, 则第$i$ 次请求时，只需要选择一个 $s_i^*$ 使得以下目标最大化即可，其中 $\lambda$ 是控制均值 PK 分在约束范围内的pacing 系数（多约束情况下会有多个 $\lambda$）;C 是常数项对所有候选都一样，在下面被忽略了

\[s_i^*=\arg\max_{s_i}\;F(s_i)\left[(V_i -\lambda s_i) \right]\]

问题二：降低成本

在这个问题中，需要保持业务收益不变前提下，尽量降低 PK分，可以把问题形式化为如下的形式。其中目标是最小化 PK分（暂时也以均值为例），$T$ 是竞胜率约束（近似 load 约束）

\[\begin{aligned}\min_{s_i} \quad& \frac{1}{n}\sum_{i=1}^{n} s_i F(s_i) \\\text{s.t.} \quad& \frac{1}{n}\sum_{i=1}^{n} F(s_i) = T\end{aligned}\]

则同样通过拉格朗日推导，可得到下面的对偶函数

\[\mathcal{L}(s_i,\lambda)=\frac{1}{n}\sum_{i=1}^{n}s_i F(s_i)+\lambda \left(\sum_{i=1}^{n} F(s_i) - nT \right)\]

最终的决策目标，即每次选择一个 $s_i^*$, 使得下面的最小即可，其中 $\lambda$ 是控制竞胜率在约束范围内的 pacing系数

\[s_i^* = \arg\min_{s_i}\;F(s_i) \cdot\left(s_i - \lambda\right)\]

这里的 $\lambda$实际上充当了 “边际胜率价值” 或 “价格阈值” 的角色。如果分析 $F(s_i) \cdot (s_i - \lambda)$ 这个式子,这里有两种情况

当流量很便宜时 ($s_i <\lambda$): $s_i - \lambda <0$ ，要让结果（负数）最小，我们需要 $F(s_i)$（胜率）越大越好，尽量出高价去赢（因为这笔买卖划算）。
当流量很贵时 ($s_i >\lambda$):$s_i - \lambda >0$ 是正数, 要让结果（正数）“最小”，我们需要 $F(s_i)$（胜率）越小越好（接近0），需要尽量不出价或出低价放弃（因为这笔买卖亏了）

实际中也是通过 PID 控制器动态调节 $\lambda$ 满足上面的约束。如果发现量不够($T$ 没达到)，就调高 $\lambda$；如果量超了，就调低 $\lambda$

方案的关键问题

Q1：竞胜率建模

竞胜率模型 $F(s)$的建模是这个方案最关键的部分之一了

最直观的思路是直接建模不同出价下竞胜的概率，而这又有 2种方式

方式一：基于日志回放，构造对应的 <出价,是否竞胜> 样本对，然后训练一个二分类模型预估，类似 ctr模型。但是这种情况下需要考虑 $F(s)$的单调性，即需要保证随着 $s$的增加，$F(s)$ 也是增加的
方式二：可以基于离线统计数据，直接做曲线拟合，这种方式能更好保证$F(s)$ 的单调性

另一种思路则不直接建模胜率，而是建模一条请求中所有分数的分布情况，有了这个分布，便能获取某个出价下的胜率情况，类似Deep LandscapeForecasting 这种方法

这种思路与前面思路的核心差异是，前者是点估计（PointEstimation），后者是分布估计（Distribution Estimation）

第一种思路的 $F(s)$建模将其看作一个二分类问题，目标是预估 $\mathbb{P}(\text{win}=1 | s,\text{context})$。这种方式，只能告诉你 “在当前分数 $s$ 下赢的概率”。如果你想知道 “如果我出$s + 0.1$胜率会变多少”，模型必须重新推理，推理成本较高。更重要的是，它很难描述竞争强度的确定性

而 Deep Landscape Forecasting这类方法，预估的是对手最高分的概率分布参数（假设是高斯分布，参数为 $\mu, \sigma$）。一旦有了分布函数，你可以直接通过 $F(s)= \Phi(s; \mu, \sigma)$ 得到任意出价下的胜率。且在这种 $\sigma$（方差）具有明确的物理意义：它代表了当前请求竞争的不确定性。如果User 侧历史特征显示这个用户经常看直播（竞争激烈且不稳定），$\sigma$ 会变大。在对偶优化逻辑中，大的$\sigma$会自动触发 “保守出价”，防止因为预估偏差导致的丢量

对于点预估的建模方式而言，“差一点就赢（对手分 1.01，你出1.0）” 和 “惨败（对手分 5.0，你出1.0）” 在模型眼里是一样的，但在分布预估中都是能被建模到的，这也使得分布预估对 “竞争景观（Landscape）” 的刻画远比二分类模型精准，尤其是在你尝试通过Shading 压低分数时，DLF能更准确地告诉你 “压到什么程度会遇到竞争对手的密集区”

因此，在以下几种情况下，类似 DLF这种建模分布的方法必要性会比较强：

1）分值分布极不均匀：如果竞争对手的分数经常在某些特征下聚类（比如晚高峰的分数陡增），DLF的分布描述能力能帮你避开这些竞争红海
2）对丢量极度敏感：如果不能接受因为 Shading 过头导致的load 掉坑，DLF 的方差 $\sigma$提供的 “安全边际” 是二分类模型无法给出的
3）算力受限：无法在线上对 $F(s)$ 进行多点采样搜索，DLF推理一次、解析求解的方案是唯一选择

关于 DLF 的细节可以参考 Deep Landscape Forecasting forReal-time Bidding Advertising，这里只说 DLF 的一些核心关键点

DLF 的核心在于不直接建模胜率，而是建模竞争对手最高分 $Z$ 的概率分布 $P(Z|\theta)$。假设 $Z$ 服从对数正态分布(Log-Normal)，模型输出参数 $\theta = (\mu,\sigma)$。建模的细节如下

1. 核心公式定义

概率密度函数 $f(z |\theta)$：描述对手最高价恰好等于 $z$ 的概率
累积分布函数 $F(s | \theta) = P(Z ：即当前业务在出价 \(s$时的竞胜率
生存函数 $S(s | \theta) = 1 - F(s |\theta) = P()$：即出价 $s$依然无法获胜的概率

2. 损失函数推导

在训练阶段，样本存在典型的右截断（Right-Censored）特征,即在竞败后只知道 $Z \ge s$但不知道大多少。DLF 采用负对数似然（NLL）损失函数：

\[\text {Loss} = \sum_{i \in \text {win}}\underbrace {-\log f (Z_i | \theta_i)}_{\text {针对已知竞争价的回归}} +\sum_{i \in \text {loss}} \underbrace {-\log S (s_i |\theta_i)}_{\text {针对截断数据的约束}}\]

对于赢了的样本：我们知道真实的竞争最高分 $Z_i$（二价分），此时通过 PDF最小化残差
对于输了的样本：我们只知道 $Z_i >s_i$。生存函数项会强迫模型学习到 “对手分布必然在我的出价之上” 这一约束

3. 线上解析决策

由于 $F(s)$ 被参数化为已知分布（如$\Phi$ 函数），在求解 $s_i^*$时，我们可以直接利用其解析性质，比如说对于上面的问题一，找到一个 s使得上面的目标值最大化，则可以直接求一阶导，则一阶导为 0的值即为需要知道的那个 s

\[\frac{\partial}{\partial s} [F(s)(V -\lambda s)] = 0\]

进一步整理可得

\[F'(s) \cdot (V - \lambda s) -\lambda F(s) = 0\]

\[\frac{F(s)}{F'(s)} + s =\frac{V}{\lambda}\]

DLF（Deep Landscape Forecasting）的妙处在于它假设 $F(s)$服从某种具体的数学分布（比如对数正态分布Log-Normal）。一旦分布确定了，$F(s)$和 $F'(s)$就不再是黑盒，而是带有参数 $\mu,\sigma$ 的具体公式。以对数分布为例

$\Phi$ (CDF)：$F(s) = \Phi(\frac{\ln s -\mu}{\sigma})$

$\phi$ (PDF)：$F'(s) = \frac{1}{s\sigma} \phi(\frac{\ln s -\mu}{\sigma})$

这种方式使得系统无需在线上进行繁琐的离散采样搜索，仅需一次推理即可秒级定位最优Shading 点

Q2：Feedback Loop 问题

进行 Score Shading后，观察到的 “胜率” 是基于削减后的分数的。而由于出价变低，观察到的竞争环境会显得更 “难赢”，导致$F(s)$进一步下修，陷入出价越来越低的死循环

具体的解决思路也很常见，就是引入 Epsilon-Greedy探索机制，在开一个小流量探索实验，在这个实验上保持原始 Score出价，用以收集真实的、无偏的竞争分布数据

系统性风险

在单个业务线看来，Score Shading是一个完美的局部优化工具；但站在整个平台的视角来看，如果各个业务线都各自为战地进行Shading，就会引发经典的博弈论困境，甚至导致整个分发系统的崩溃

潜在问题

如果平台放任各业务方（短视频、图文、电商、直播等）自行引入 PID控制器进行 Score Shading，系统会面临以下问题：

(1) 分值通缩与体验 “破窗”（Race to the Bottom）

假设图文和直播都在争夺同一个版面：直播为了降低分值成本开启Shading，分数从 1.0 降到 0.8。图文发现竞争变弱了，它的 PID控制器也会自动向下 Shading，从 0.9 降到 0.7 就能赢。直播的 PID 发现 0.8胜率依然很高，继续降到 0.6……

这容易导致全局排序分（MixRankScore）发生剧烈的左偏。很多平台在混排底层和前端展示逻辑中，会有硬性的 “体验保护门槛”（比如Score < 0.3视为低质内容，直接过滤）。分值通缩会导致大量优质内容跌破绝对值门槛，引发大面积的 “空出”（前端开天窗）或低质保底内容泛滥

(2) 多 PID 耦合引发的震荡（Oscillation &Chaos）

在混排系统中，某种程度上流量是一个零和博弈。当直播的 $\lambda_1$ 控制器和短视频的 $\lambda_2$控制器同时作用于同一个流量池时，两者会形成复杂的非线性耦合。比如说晚高峰时，直播稍微调高了一点分数获取了流量，短视频的获量（Load）瞬间下跌，短视频的PID 会立即进行剧烈的反向补偿（拉高分数）

这会导致线上流量分配出现高频的脉冲式震荡。比如说上一分钟全是直播，下一分钟全是短视频。这种流量的不稳定性不仅会毁掉用户体验，还容易导致底层服务器的算力潮汐，引发系统过载

解决思路

为了缓解所有业务同时做 shading带来的上面的问题，一般有两个思路：设立一个全局的 “分值锚点（Anchor）”，或引入统一的拍卖机制（如VCG）来给每个业务记账，以保证整体混排系统的稳定性和激励兼容

方案一：确立 “全局锚点”（Global Anchor）

在没有锚点的混排系统中，各个业务的 Score Shading就像是各个国家在疯狂印钞和货币贬值（为了出口 / 抢量）。由于一价 pk只看 “相对大小”，如果不加限制，系统的绝对分值就会无限坍缩（通缩）。全局锚点的本质，就是建立混排体系的 “金本位” 或 “美元结算体系”

具体做法是平台强制规定：某一个占主导地位的核心业务（通常是占比 70%以上的自然推荐图文或短视频），绝对不允许进行任何形式的 ScoreShading。它的 pk 分必须 100% 诚实地反映预估的业务价值（TrueValue，如预估时长、预估互动率的某种线性或非线性加权）；又或者是广告这种pk 分（ecpm）就具备天然的物理含义且不容易有突变的业务

通过固定锚点之后，其他变现业务（直播、电商、本地生活）的 Shading行为就有了实体的 “物理底座”。它们在向下挤压分数时，一旦低于锚点业务的真实价值，就会立刻丢量。这就形成了一个天然的价格托底（PriceFloor），从而避免了 “Race to the bottom” 的系统性崩溃。

方案二：所有业务走统一拍卖机制（如 VCG）来记账

虽然 VCG一般是广告计费场景中的概念，但如果为所有业务都通过这种方式记录胜出的体裁对平台造成的 “机会成本”，能够从机制上消除各业务方进行Shading 的动机

VCG机制的核心逻辑是：业务方不再按自己的 “出价” 付费，而是按其对系统造成的 “社会成本” 付费。通俗理解就是，你赢了，是因为你把别人挤下去了。你付出的成本，就是被你挤掉的那些人所损失的价值总和

具体的计算逻辑是，按照各业务给出的 pk 分排序，如果业务 A赢得了某个坑位，它需要支付的 “价格” 等于：“如果没有 A参与，系统中其他所有业务方能获得的总价值” 减去 “在 A参与的情况下，系统中除 A 以外其他业务方获得的总价值”,如下是一个例子

假设当前有 3 个坑位，业务 A 参与时，系统最优排布是 {A, B,C}，总价值为 $W = V_A + V_B +V_C$。则通过 VCG 计算 A 应该支付的价格的步骤如下

（1）计算全集最优价值 $W$
（2）模拟 “如果没有 A” 的情况。此时系统会填补进来一个业务 D，最优排布变为{B, C, D}
（3）A 应当被收取的 “分值成本” $P_A =(V_B^{new} + V_C^{new} + V_D) - (V_B^{old} + V_C^{old})$。

VCG 是实现激励兼容（IncentiveCompatibility）的重要手段。激励兼容是博弈论机制设计中的一个核心概念。简单来说，如果一个系统是 “激励兼容” 的，那么参与者（各业务线）“说真话”（按真实业务价值出价，truthfulbidding）就是他们的最优策略，任何伪装或调分都会损害他们自身的利益。VCG实现激励兼容的核心点在于，它将个体利益与整体利益完全对齐，我们看如下两种情况

（1）如果业务方 A 故意报高分（PositiveShading），它虽然增加了赢的概率，但它支付的 VCG成本是由排在它后面的业务决定的。如果它真实价值不够，支付的成本就会超过其真实收益，导致亏损
（2）如果业务方 A 故意报低分（NegativeShading），它只会降低自己赢的机会，而不会降低它赢了之后要支付的成本（因为支付成本与它自己的报价无关）

因此，在 VCG 机制下，各业务方会发现，任何 Shading行为都不会带来额外收益，唯有如实上报预估价值才能获得最大化盈余

但是，VCG在数学上近乎完美，却在工业界混排场景中面临巨大的落地压力

首先是计算复杂度的爆炸，VCG要求对每一个胜出的业务都进行一次 “如果没有它” 的模拟重排。如果有 $N$ 个坑位，理论上需要进行 $N+1$次完整的混排计算。在高性能要求的推荐引擎中，这会带来巨大的计算延迟

其次是不同价值量纲对齐问题，VCG 的前提是 $V_B + V_C$ 必须是可加的。但直播的 1分钟时长和短视频的 1分钟时长，对用户留存的贡献真的可以直接相加吗？更不用说还存在这广告ecpm、电商 gmv等各种业务天然量纲就对不齐的业务指标。而如果这个全局价值函数 $f(V)$ 定义得不准，VCG就会产生严重的误导性收费，导致整个生态向某个体裁极度倾斜，引发系统崩盘

因此，VCG虽然理论上非常完备，但面临的问题是实现的复杂度高，往往是在业务进入精细化阶段，追求绝对公平分配阶段才会推进，这种方式下其实就不允许score shading了。而在业务早期，往往是用方案一，更有利于各业务快速迭代

总结

本文从广告领域的 Bid Shading概念出发，深入探讨了其在信息流混排场景下的延伸 ——ScoreShading。通过将混排 PK分建模为业务方的 “隐式出价”，不仅打通了广告机制与推荐算法之间的壁垒，还为多业务体裁的渗透率优化与量纲控制提供了严谨的数学框架

Score Shading 的落地依赖于以下三个维度的协同

对偶优化的决策框架：利用拉格朗日对偶性（LagrangianDuality），我们将全局的业务约束（如 Load 占比、平均 PK分）拆解为单次请求下的实时决策问题。通过 PID 等控制器动态调节 $\lambda$，系统能够地感知大盘动态波动，并在 “收益最大化” 与 “成本受控” 之间找到动态平衡点
竞胜率模型建模：通过点预估和分布建模的方式，建模在特定出价下的竞胜概率。相较于常规的点预估方式，类似DLF的分布建模范式，模型不再仅仅给出一个孤立的胜率数值，而是描绘出整个竞争环境的 “景观（Landscape）”。这种分布估计的方法，配合线上解析求导决策，既保证了Shading 过程的单调性与稳定性，又极大地优化了工程实现的算力效率
系统级稳定性的博弈治理：Score Shading虽是业务局部优化的利器，但必须防范 “分值通缩” 与 “多方震荡” 的系统性风险。无论是建立全局锚点（Anchor）的 “金本位制”，还是探索VCG机制下的激励兼容性，其核心目的都在于将个体的局部利益与平台的全局生态利益对齐

随着混排场景日益复杂，简单的绝对值比较正逐渐向复杂的机制博弈演进。ScoreShading不仅仅是一个调分技巧，它本质上是平台治理能力建模化的体现。未来，如何在保障各业务方 “公平感” 的同时，进一步引入强化学习（RL）来处理更长周期的约束（如长效留存LT），将是混排优化领域值得持续探索的深水区

User Experience Optimization: From Heuristic Intervention to Unified Value Modeling

2025-12-08T00:51:23.000Z

In the evolution of Search, Ads, and Recommendation systems, UserExperience (UX) is an unavoidable core challenge. In this article, wequantify UX as LT (Life Time), specifically referring to user retention(e.g., the number of days a user opens the app within a 7-daywindow).

Unlike pure content recommendation, which seeks to maximize totalwatch time, optimization in commercial or marketing-oriented sectors(Ads, E-commerce, Live Streaming) is about maximizing business value(Cost, GMV, etc.) while staying above a “UX Redline.” More accurately,it is about maximizing the efficiency of exchanging “Unit LT”for “Business Metrics.”

We typically use Holdout Experiments (Reverse Experiments) to measurehow a business strategy affects LT. The factors influencing theseresults are multifaceted:

Explicit Factors: These are the most direct and well-known,involving the position and density of business items (e.g., start_pos,gap, load).
Implicit Factors: Supply quality and ranking accuracy. The qualityand diversity of ad creatives or live-streaming content determine theappeal of the distribution queue. If supply is insufficient or rankingis inaccurate, users are less likely to be attracted to theplatform.
Opportunity Cost (Backfill Logic): A frequently overlooked point. Aholdout experiment compares the “Business Queue” with a “Backfill Queue”(usually the organic recommendation queue). The final impact on LT isessentially:

\[\Delta LT = LT_{Business} -LT_{Backfill}\]

The negative impact on LT is minimized only when the business contentis as attractive as—or more attractive than—the organic content itreplaces.

While improving supply and ranking accuracy are the fundamentaldrivers for LT, they take time to yield results. In day-to-dayengineering, adjusting load, start pos, and gap remains the mostimmediate lever. Furthermore, we must establish strict defensivemechanisms to prevent short-term gains from masking long-term,cumulative UX damage.

This article explores the evolution of UX optimization through threestages: Short-term Defense (Heuristic Protection), Mid-term Tuning(Experience Modeling), and Long-term Alignment (Unified ValueModeling).

Short-termStrategy (Heuristic Defense & Protection)

In the early stages, the most effective tools are rule-basedstrategies based on traffic attributes or user segments. The core logicis “Rapid Loss Prevention” and “Layered Defense.”

By manually or semi-manually “patching” the system (e.g., raisingthresholds for specific segments), we protect high-risk or sensitiveusers. This includes protection for new users, returning users, orlow-activity users. In search, it might involve setting differentthresholds for “active intent” vs. “passive browsing” traffic.

Implementation Logic

We segment traffic by request features (e.g., channel entry) or userprofiles (e.g., historical report/bounce rates). Mechanistically, we setindependent, higher eCPM thresholds or increase start_pos/gap losses inthe ranking stages to ensure business content is reduced or removed forthese segments.

Pros: Simple to implement, low experimentcost.
Cons: Purely reactive (post-hoc), lacks generalization,and can easily become obsolete.

The Paradox: Why do these “patches” work?

If a system has a Static Threshold, it has theoretically fixed theexchange efficiency between business goals and LT. For example, in ads,a fixed eCPM threshold dictates that a “show” must bring in atleast $X$ revenue to justify the LTloss.

In an ideal world, a single static threshold should be globallyoptimal. However, these patches work because of three realities:

1.Value Estimation Bias: The system may overestimatethe eCPM for certain groups (like new users). Raising the threshold actsas a manual calibration for this overestimation.
2.UX Loss Heterogeneity: Even if value estimation isaccurate, the LT loss from the same “show” varies by user. A sensitiveuser might churn after one bad ad, while a resilient user remainsunaffected.
3.Suboptimal Exchange Efficiency: Even with perfectpredictions for value and experience, the “weight” given to each in theranking formula might not be globally optimal.

However, while patches are necessary today, they shouldn’t existpermanently. The goal is to improve the accuracy of both value andexperience modeling and optimize their exchange ratio.

Mid-term Strategy(Experience Signal Modeling)

Heuristic strategies rely on the assumption that certain groups aresensitive. Mid-term optimization moves away from manual interventionstoward dynamic, model-driven interventions.

We explicitly model the user’s experience loss.We can categorizethese modeling approaches into two types:

1. Direct Experience Signal Modeling(Correlation)

Offline: Predict the probability of negative behaviors (leave,report, dislike) after a given exposure: $P(Negative | Context)$.
Online: Based on the predicted probability, dynamically increasethresholds or gaps to reduce “Load” for that specific request.

2. Uplift Modeling (Causality)

Offline: Use causal inference to model the change in LT ($\Delta LT$) and the change in businessvalue ($\Delta Cost$) when a“Treatment” (showing a business item) is applied.
Online: Calculate the Marginal Exchange Efficiency

\[Efficiency = \frac{\Delta LT}{\DeltaCost}\]

We select traffic and users with the highest efficiency to perform“LT recovery” (reducing load), maximizing the LT regained for everydollar of revenue sacrificed.

However, uplift modelling has the following challenges:
(1) Label Sparsity: LT is a long-term, sparse metric.We often rely on Proxy Metrics (e.g., short-term stay time,interaction), and the correlation between these proxies and true LTdetermines the model’s success.
(2)Counterfactual Data: Uplift models require“Treatment” and “Control” data. This requires a small portion of“exploration traffic” where ads are withheld, which can be costly.

Long-term Strategy(Unified Value Modeling)

The ultimate goal is to move away from “patching LT” and insteadtreat experience signals as a “Unified Currency” that isinterchangeable with business metrics (Revenue, GMV).

We no longer treat LT as an external filter but as an internalcost/benefit within the Ranking Formula, enabling automated end-to-endoptimization.Deriving the Optimal Ranking Formula

Most ranking problems can be formalized as a constrained optimizationproblem. For an ad queue:

\[\begin{align}\max_x &\sum_{i=0}^{n-1} ecpm_i \\s.t. \frac{1}{n} &\sum_{i=0}^{n-1} lt_i \ge LT^{*}\end{align}\]

Using the Lagrangian Dual, we can derive the ranking score, similarderivation process can be found here 《搜索相关性：从建模到排序机制》

\[Score_{i} = ecpm_i + \lambda \cdot(lt_{i} - LT^{*})\]

Here, $\lambda$ acts asthe “Shadow Price” of LT—the exchange rate between LT and eCPM.If a user’s predicted $lt_i$ for aspecific request is high, the final $score_i$ increases, making the item morelikely to win.

There are several key considerations in this method

Proxy Metrics: Since direct LT prediction isdifficult, we use easily observable process metrics as proxies.
Listwise Context: The best place for thisprediction is the Evaluator/Rerank stage, where the model has the mostcontext to predict how a specific sequence of items affects LT.
Solving for $\lambda$: $\lambda$ is not static. It can be solvedvia offline replay of historical data to find the global optimum oradjusted in real-time via a PID Controller to ensure the LT constraint($LT^*$) is met.

Though the key considerations are described briefly here, each partactually requires detail investigation in order to solve the problemproperly

Conclusion

User Experience optimization in complex search, ads, recommendationis not a one-time fix but a layered, systematic challenge.

Short-term (Heuristic Defense): Focuses on rapid identification andloss prevention. It uses “patches” to protect the system when valueestimation or exchange rates are not yet optimal.

Mid-term (Experience Modeling): Uses correlation or Uplift models toscientifically quantify experience. It makes hidden costs explicit andprovides the data foundation for long-term integration.

Long-term (Unified Value): The final form of optimization. It breaksthe duality of “Business vs. Experience” by converting UX into a“Unified Currency.” LT becomes a native value participating in automatedresource allocation.

These three stages represent an evolution from Local Optima towardGlobal Optima. In practice, they should coexist: use short-term rules tohold the redline, mid-term models to improve efficiency, andcontinuously iterate toward the ideal of unified modeling.

用户体验优化概述：从规则防御到价值统一建模

2025-12-08T00:51:23.000Z

在搜广推业务的演进过程中，用户体验（本文量化的方式是 LT，即用户在 APP的留存情况，如 7 天内有几天打开了app）是一个绕不开的核心命题。与纯内容推荐追求用户时长最大化不同，在广告、电商、直播等商业化或营销导向的业务中，用户体验优化的本质是在体验红线之下，寻求业务价值（Cost,GMV 等）的最大化；或者更准确地说，是追求单位 LT兑换业务指标效率的最大化

通常，我们通过反转实验（Holdout Experiment）来度量业务策略对 LT的影响。而影响反转实验 LT 指标的因素非常多：

显性因素：这是最常见和为人熟知的因素，指的是对应业务的 item在展现时的位置和密度（比如说 start pos、gap、load 等）
隐性因素：供给侧的质量与排序侧的准确性。例如广告素材、直播间内容的质量与多样性，直接决定了分发队列的吸引力，都会直接影响分发的素材的多样性，进而影响用户是否会更容易被平台的内容吸引，这部分其实也跟我们系统的排序能力相关，因为除了供给需要充足，也需要准确的排序能力来把合适的内容推送给不同的用户
机会成本（回填逻辑）：这是常被忽略的一点。反转实验的本质是比较 “业务队列” 与 “回填队列（通常是自然推荐队列）” 的价值差异。业务策略对LT 的最终影响，实际上等于 (业务内容的 LT) - (被挤占的自然内容的LT)。只有当业务内容的吸引力接近甚至超过自然内容时，LT的负向影响才会最小化

因此，虽然优质供给和精准排序是提升 LT的根本，但其见效周期长。在实际工程迭代中，通过调控 Load、Start Pos 和Gap 往往是影响 LT最直接、见效最快的手段。此外，我们在追求业务增长的同时，必须建立严格的防御机制，防止因观测周期滞后，导致短期不可观测的体验受损在长期累积成巨大的负向效应。

本文将探讨用户体验优化的演进路径，将其归纳为短期防御（规则圈选）、中期调优（体验建模）与长期对齐（价值统一）三个阶段。

短期策略：规则防御与圈选保护

在优化的初期，最常见且有效的手段是基于流量属性或人群特征的规则类策略。其核心逻辑是“快速止损” 与 “分层防御”：通过人工或半人工的方式识别高危 / 高敏流量，针对识别的预估不准确或敏感人群，通过差异化 load策略（如门槛、start_pos、gap），即刻降低其体验受损风险

体验中常见的分人群、分流量类型等抬门槛等保护策略，就是这一类策略。其核心思路是通过人工/半人工的 “打补丁” 策略（分人群、分流量抬门槛）快速保护高危/高敏用户。这种思路在多个业务场景中都验证了其有效性。常见的如新用户保护、回流用户保护、非月活用户保护，或者是搜索中区分主、被动流量设置不同的门槛，都属于这一类思路

具体的实现逻辑也比较简单，往往是通过流量侧或人群侧的分层（往往需要一些数据分析来支持论证划分的有效性），比如说基于请求特征（如频道入口等）进行静态分流；或者在人群侧基于用户画像/历史行为（如新用户、低活用户、历史高举报/高跳出率用户等）进行动态人群包圈选

而在机制上，一般是在在排序不同阶段，为这些流量/人群包设置独立的、更高的门槛，或者设置更大的start_pos loss/gap loss 来实现这些内容少出或不出的目的

这类方法的优点是简单和实验成本低；缺点则是纯后验规则，缺少泛化性，容易失效

基于规则的这些短期策略虽然能快速止损，但是一个值得探讨的问题是：为什么这些分流量、分人群策略会有效？

从流量视角，如果我们系统中有一个静态门槛，静态门槛已经固定了业务优化目标跟LT 的兑换效率。以广告为例，最大化目标是收入（ecpm），而固定的 ecpm门槛约束了 ecpm 和 LT 的边际兑换效率（更直观的理解，show 导致的 ltloss，至少要带来这么多的 ecpm 收益）。把上面的 ecpm换成其他业务目标，原理类似

因此，静态门槛控制了整体的业务优化目标与 LT 的兑换效率，打平load 的情况下，最优的门槛应该是一个静态门槛

那为什么很多体验分流量类型，分人群包去抬门槛来保护是有效的？我们可归纳为以下三个关键事实：

1）价值预估偏误：对于某些人群（如新用户），系统可能高估了其业务价值（如 ecpm）。抬高门槛相当于手动提高了这部分流量的兑换比，某种程度上是了这部分流量高估的校准
2）体验损失异质性：即使价值预估准确，相同的曝光（show）对不同用户造成的 LT 损失也不同（比如说敏感用户可能因一次不当曝光而流失，钝感用户则无感）。这需要系统能准确建模用户体验
3）兑换效率非最优：即使价值和体验均能准确预估，两者在排序公式中的权衡（兑换比）也可能不是全局最优的

因此，统一静态门槛实现全局最优的前提非常苛刻：价值预估准确、体验项预估准确、且两者的兑换效率已是最优。当任一条件不满足时，分人群 / 流量的策略便成为有效的 “排序补丁”

但长期看，应该通过把价值项和体验项做准，并且优化两者的兑换比，然后通过统一门槛来调控业务优化目标和LT的兑换比；分流量、分人群的策略是短期的补丁手段，长期看不应该存在线上

中期策略：体验信号建模与干预

上面说的圈选策略，是基于某一个或几个特征（如人为对人群划分和流量划分的纬度）。然后基于“这些人群的的LT 与业务指标兑换效率较低” 的假设，对这部分人施加降 load的操作来降低对 LT 的影响，同时尽可能让业务指标无损

但这种方式的泛化性有限，依赖的假设可能会随着分布变化而不成立，因此更泛化的方式是通过建模去预估这些体验指标的变化。将用户的体验损失进行显性化建模。由上面定义的人工门槛干预，转向动态的、基于预估体验的干预手段

这种方式的核心思路是对用户的体验信号进行建模，然后基于建模的预估值，对用户施加更加个性化与效率更高的回捞策略。根据建模方式的不同，常用的建模方式可以分为两大类

体验信号直接建模：直接建模与用户 LT 相关的负向行为（如leave、report、dislike）的概率，然后基于预估概率对用户施加不同的降 load策略，属于相关性建模
uplift 建模：建模不同用户单位曝光（load）与 LT关系，提升业务目标（如直播的 awld）与 LT 的边际兑换效率，提升 LT回捞的效率，属于因果性建模

由于讲建模的文章比较多，这里只是简单介绍下这两种建模方式的主要思路

（1）体验信号建模（相关性）

离线建模：预估用户在给定曝光后，触发负面体验行为的概率
线上生效：基于预估的负向行为概率，通过提升门槛、后移 start position或增加 gap 来降低用户看到的直播的 load

（2）uplift 建模（因果性）

离线建模：利用因果推断方法，建模用户在施加 treatment后（如是否看到业务 item）带来的 LT 变化（$\Delta LT$）和业务指标变化（如广告是$\Delta cost$）
线上生效：基于预估值，计算边际兑换效率，即 $\frac{\Delta LT}{\Deltacost}$，选择兑换效率高的流量和人群来做 LT的回捞（同样通过上面限制 load 的方式即提升门槛、后移 start position或增加 gap），从而达到打平业务指标的损失下，最大化回捞的 LT

这种方式的优势是，相较于基于规则的圈选，建模有更好的泛化性；同时通过uplift 建模优化业务目标与 LT的边际兑换效率。但是面临的挑战是建模难度会比较大，主要体现在1）无论相关性或因果性建模都会遇到，label 获取问题，LT是一个稀疏且长周期的指标，直接建模极难收敛，需要找一些相关的代理指标，这些代理指标跟LT 指标的建模难度和与 LT 指标的相关性都会影响最终的建模效果 2）uplift建模依赖获取反事实数据的准确性（即 label的准确性），但严格上来说是没法获取到绝对的 ground truth的，实际中会通过各种方式来模拟，同时为了获取label，需要有一部分探索流量少出或不出直播，对线上有损（利用不出 item反转损失可控）

长期策略：体验价值统一建模与兑换

无论是短期方案还是中期方案，都是基于先验的知识，或模型预估的体验信号，然后人工构造的规则（如前x 刷不出）或 listwise loss 生效（如 gap loss、start posloss）到最终的排序中，其都依赖人工构造特定的操作（如后移 start pos、缩小gap 等）对线上体验的增益或损失

而长期方案的目标是彻底摆脱 “为 LT单独打补丁” 的逻辑，将体验信号（LT损失 / 增益）转化为与业务指标（如收入、gmv、直播观看时长）可等价交换的 “统一货币”，并在分发链路中实现端到端的自动化博弈。其核心思路是不再将LT 视为一个外部拦截条件，而是将其量化为一个体验成本 / 收益，直接进入 Rank排序公式

最优排序公式推导

由于大混排不同队列都有其最核心的优化目标，因此理论上所有问题都可以量化为一个带约束的最优化问题，以广告队列为例，最大化的目标ecpm 。假设有 $n$ 条请求，第 $i$ 条请求广告的 ecpm 为 $ecpm\_i$，LT 的预估值为 $lt_i$（这里先用 lt 的原始定义，即 n天内有几天打开了 app，实际建模往往需要用代理指标来替换），LT 的约束为$LT^{*}$（当前仅考虑 LT约束，多约束推导过程类似），则需要求解的问题的可形式化表达为如下

\[\begin{align}\max_x &\sum_{i=0}^{n-1} ecpm_i \\s.t. \frac{1}{n} &\sum_{i=0}^{n-1} lt_i >= LT^{*}\end{align}\]

则通过拉格朗日对偶推导，可以推导出排序公式如下，推导过程与《搜索相关性：从建模到排序机制》类似

\[score_{i}= ecpm_i + \lambda \cdot(lt_{i} - LT^{*})\]

这里的 $\lambda \cdot (lt_{i} -LT_{redline})$ 即是与 ecpm对齐量纲的体验价值。直观理解这一项，如果当前用户预估在当前请求的 $lt_i$ 值越大，则最终的 $score_i$越大，越容易胜出，反之越难胜出

这种方式有几个关键点 1）由于 LT直接预估的难度会比较大，因此往往需要找一些易于观测的过程指标作为代理指标，这个问题跟中期方案类似，其实建模思路都会遇到这个问题2）预估的位置，混排最终 evaluator 阶段选择候选具备最充分的上下文 context信息，理论上能够充分建模的上下文 context 对 LT的影响。因此可以考虑在混排通过 listwise 模型模型建模对 LT 影响 3）$\lambda$ 参数求解,通过历史回放求解最优的 $\lambda$ 或者通过控制器实时调控。由于 LT不是一个每时每刻都需要满足的约束，因此可以考虑用历史数据做天级别的回放来求解最优的历史

虽然这几个关键点都是一笔带过，但实际中每一点都会对结果有重要影响，每一点都值得写一篇文章来详细说明（这里就先挖个坑）

小结

用户体验优化，尤其是在搜广推这类复杂业务场景下，并非一个简单的、一蹴而就的工程问题，而是一个需要分阶段、分层次应对的系统性挑战。本文将其梳理为短期、中期、长期三个递进式的策略范式，它们分别对应着应急防御、精准干预和系统重构的不同层次需求。

短期策略（规则防御）核心在于快速识别与止损。它通过分人群、分流量的规则化 “补丁”，在价值预估偏误、体验损失异质性问题尚未解决时，为系统提供最直接的保护。其价值在于工程上的简单高效，但本质是对非理想现状（预估不准、兑换率非最优）的被动适应，缺乏泛化性与前瞻性

中期策略（体验建模）通过构建体验信号模型（相关性）或 Uplift 模型（因果性），我们试图更科学地量化用户体验的损失与收益，并基于预估值进行动态、个性化的干预。这一步的核心贡献在于将隐性的体验影响显性化，并为长期的系统融合提供了关键的数据和模型基础。其挑战则在于信号稀疏、建模复杂以及探索成本

长期愿景（价值统一）是用户体验优化的终极形态，旨在彻底打破 “业务” 与 “体验” 的二元对立。其核心理念是将体验价值转化为与业务目标同质、可自由兑换的 “统一货币”，并通过最优化理论将其内化于排序公式之中。这不再是为 LT “打补丁”，而是让 LT 作为一项原生价值，直接参与端到端的自动化博弈与资源分配。实现这一愿景的关键，在于能否找到可靠的体验代理指标，以及能否稳健地求解价值间的动态权衡参数（即上面公式中的$\lambda$）

从本质上讲，这三个阶段刻画了一条从 “局部最优解” 逼近 “全局最优解” 的演进路径。在实践中，它们并非相互替代，而应协同共存：用短期规则守住底线，用中期模型提升效率，并持续朝着长期统一建模的理想架构迭代。未来的用户体验优化，必将是更深度的价值量化、更智能的实时调控，以及更彻底的系统级价值对齐

出海、选择与 “弯路”

2025-10-05T23:51:23.000Z

许多人大概都读过这段充满宿命感的话：

当你老了，回顾一生，就会发觉：什么时候出国读书、什么时候决定做第一份职业、何时选定了对象而恋爱、什么时候结婚、其实都是命运的巨变。只是站在三岔路口，眼见风云千樯，你作出抉择的那一日，在日记上，相当沉闷和平凡，当时还以为是生命中普通的一天

这段自出《杀鹌鹑的少女》的文字，具象化了选择的厚重感。而事实上，很多 “当时只道是寻常” 的瞬间，确实会这个名为 “人生” 的游戏开辟很多新的分支。最近几天在玩Detroit:Become Human这款游戏，通过三个仿生人（androids）徐徐展开讲述了一个有关人工智能、科技、伦理、人性的故事，而故事的结局是由你在游戏中的种种抉择所决定的，你的一个不经意的选择，可能会掀起一场人类与仿生人的流血革命

都说选择大于努力，我们特别擅长拿着后视镜去度量一个选择的 “好” 与 “坏”。因为我们没有上帝视角去获取整个游戏的FlowChart，去看到那些未选择之路种种；更要命的是，我们在当前已选择的道路上的任何操作无法撤销或回滚，当最终的结果不太如人意时，就会在事后复盘时被打上一个 “走了弯路” 的标签，然后幻想那条未选择的道路所拓展出来的分支

最近就面临着一个关于出海的选择，一直觉得出海是国内企业发展的未来，但是真正面临这样的选择时，也少不了瞻前顾后、忧心忡忡，总想小心翼翼地迈出下一步，希望少走 “弯路”。脑子里的各种观点打架打了好多天，我觉得是时候写一篇文章来梳理一些这个迷思了。本文是关于出海和选择的一些碎碎念，祝开卷有益～

关于出海

“失落” 日本的出海史

B 站有个分析师 up 主针对日本的出海历史做了一个出海专题，从宏观角度讲述了日本的出海历史，同时提供了个人在这种大环境下的一些选择。最近又出了一本《以日为鉴》的书籍，虽说历史不会重演，但免不了会有惊人的相似性，可以读一下作为参考（下面的这些数据基本来自这些视频和书籍，但豆瓣的书评提到，这本书的一些数据可能不够权威，笔者在引用时也会尝试找到其出处）

海外再造日本

截止 2022 年末，日本的海外净资产达到了 418万亿日元。与此相比，当年日本国内总额为 545 万亿日元，由此形成了所谓 “海外再造日本” 的经济现象

日本在进入泡沫危机后，首先遇到的最大问题就是增量减少。以房产投资和日常消费为代表的内需走向低迷。泡沫破裂前，80 年代日本雇员薪资增速约 5.5%；破裂后的 92 年，迅速降至 1.8% 左右，此后长期负增长，工资下滑进一步导致国内消费需求萎靡。（此时此刻，恰如彼时彼刻？）当时，日本庞大的内需市场快速萎缩，全社会从消费型转向储蓄型，市场陷入同质化竞争。内卷之下，服务业不得不提升质量以吸引客户，这倒逼出了极致的服务态度

在此背景下，日本于 1994 年开启大规模出海潮，企业利润也逐渐回升。2000 年，日本企业利润重回 1989 年高位；2007 年，全国企业利润已是泡沫经济前的 1.5 倍。上世纪 90 年代泡沫破裂后，日本对外直接投资占 GDP 比例从 1990 年的 6.5% 迅速提升至 2021 年的 40%。21 世纪的第一个十年，更实现了出口和投资双轮驱动。出口额占 GDP 比重从 95 年最低的 8% 升至如今的 20%。据大和证券统计，日本上市公司海外利润占比接近 60%，多个行业龙头海外收入超 75%

那么，这又是如何做到的？

泡沫破裂后，日本对外直接投资的动机主要包括以下几个方面（1）拓宽本国的海外品牌影响力（2）在海外重塑全球分工体系（3）利用先进技术优势换取海外市场（4）寻求低成本的劳动力。而在具体运作上，基本的逻辑是：一方面寻找中国与东盟为代表的亚洲新兴经济体利用其劳动力与市场优势，另一方面通过新兴经济体的利润反哺研发，实现欧美市场所需的技术创新

这也意味着日本对外投资活动主要以市场和技术驱动为主。日本同时需要从新兴经济体获取利润又需要和欧美企业进行竞争，事实上目前的中国也正在走上这条被追赶的路，一方面一带一路扩大在新兴国家的影响力，另一方面重复高端技术以蚕食欧美企业份额

90 年代，日本大量投资东亚新兴经济体。自 1995 年始，索尼、东芝、丰田、大金等头部企业组成产业联盟抱团出海。此轮出海目的地不再是 80 年代首选的美国，而是中国与东南亚。1995 至 1996 年，日本对东南亚直接投资占总额 20%，中国占 10%。此后数年，日本将国内产业链集中迁至不同国家，把低端产能转移到海外廉价劳动力市场，国内保留高利润的高端产能。

2000 年左右，日本商品迎来中国进口需求的爆发。中国迅速释放的内需，吸收了日本在华工厂的大量订单。日本在华工厂本地销售比例从 1999 年的 31% 猛增至 2010 年的近 70%。可以说，日本早期在华投资建厂，既赚取了廉价生产成本与土地红利，也吃到了中国发展的时代红利

在投资出海的同时，日本国内产业结构也在剧烈调整。泡沫破裂前，金融业是日本市值最高板块，占比近 30%。日股市值前 30 的公司中，一半属金融行业。金融与地产股一度占全市值 38%。

三十年后，金融股仅占 8%，地产股不到 2%。市值最高的四大行业依次为工业、消费、信息产业与医疗健康，占总额 65%。而泡沫破裂前，医疗仅占 3%，信息产业占 5%，消费品占 11%。事实上，除工业制造这一日本 80 年代的荣耀外，其余三大行业多在泡沫破裂后崛起，且基本属非制造业范畴；工业、消费、信息产业、医疗健康这几个产业，其最大市场恰恰在海外，海外收入常年高于国内。以医药龙头第一三共为例，其 2022 年日本营收仅占 35%。

普通人的出海之路

上面都是偏宏观的数据，落到普通人头上，在出海这个新游戏里，机遇又在哪里？回顾历史，会发现里面有一个比较核心的思想：在国内增长放缓时，将自身技能、商业头脑或资本与海外市场更早期的发展阶段相结合，从而获得溢价和机遇

当年的普通日本人，主要有 3 个出海增量机会。分别是工作出海，商业出海与投资出海

（1）工作出海

工作出海，或者说跟随公司出海是最主流、最稳妥的方式，也是普通人最有机会的领域

在说出海的企业对个人的影响前，可以先看一下日人普通人的择业观和变化，也许会对我们有更多启发

从就业选择看，泡沫前 80 年代，日本最受欢迎的企业中，除索尼与丰田外，几乎全是当时如日中天的金融和地产公司。泡沫时期，金融业普通员工工资是社会平均的 2.8 倍，中层干部达 4.1 倍。从业人员从 1976 年的 150 万，十年后增至近 265 万

然而，泡沫经济后的四年，日股跌 60%，地价跌 50%。日本金融业模式特殊，自成一体，缺乏国际化能力，国内业务萎缩，又难以开拓国际业务，加之房产泡沫破裂导致不良率攀升，行业盈利能力骤降。证券业首当其冲，前五年主要通过裁员降薪维持，从业人数仅降 15%。但 1997 年 11 月，日本最大券商山一证券破产，行业彻底进入破产潮。当年金融从业人口减少 60 万，部分 “幸运儿” 转入号称永不倒闭的银行业

随着 1998 年亚洲金融危机爆发，日本银行体系全面崩塌，四年间累计 150 家银行破产，日本金融业坠入深渊，大量转型银行的金融人员再度失业

尽管日本银行业于 2000 年开启重组出海，但直到 2005 年不良率才降至 3.5%，出海收入占比开始快速提升。此时，距泡沫破裂已过去十五年。尽管此时日本金融业开始吸纳海外岗位，但 90 年代的 “天之骄子” 们大多已转行，或所学知识难以适应海外业务需求。这大概就是 “时代的一粒尘，落在个人头上，就是一座山” 了

此外，泡沫破裂后，日本迎来了接近 10 年的考公热，公务员报录比例超过1:30，但随着此后持续的低薪与工作量升高，公务员逐渐被日本年轻人所抛弃，如今报录比仅为1:3

实际上，90 年代后，日本除大企业外，有三类公司异军突起：第一类是消费降级型，如优衣库；第二类是隐形冠军，如基恩士；第三类是出海抢单的非制造业企业。第二、三类企业创造了大量就业，甚至在 90 年代日本 “就业冰河期” 形成了 “出海暖流” 之说。日本出海一代，既躲过了国内经济下行的内卷，又凭借海外增量机会，摇身成为 2000 年后日本中产的主力之一

一个典型例子是技术人才。当丰田、本田等在泰国、美国设新厂时，一名在日本本土有经验的产线班长或质控员，可被派往海外，培训当地员工，确保流程与品质标准与本土一致。他们能获得可观的外派津贴，并享受当地较低的生活成本。另一种模式是日企海外子公司本地化运营，催生了对既懂技术又了解当地市场人才的需求，为日企员工加入本土企业创造了条件

工作出海这种方式的特点往往是大企业先行，中小企业随后成为主力；从配套生产到独立经营；对技术、营销人才需求大都比较大。最常见的是日本大企业在海外设厂，催生对配套供应链的需求，许多中小企业和个人创业者会为这些海外日企提供零部件和生产服务，而结果就是日本破产中小破产企业数量在 1998 年登顶后一路下滑，10 年后基本降到泡沫前水平，保住了就业的基本盘，与之相反的是韩国在遭遇金融危机后，中小企业集中倒闭后大企业一家独大的局面

（2）商业出海

商业出海指的是那些更具冒险精神的人，利用海外市场对日本产品和生活方式的好奇，开创个人事业

例如，一个曾在餐饮业工作的日本人，看到曼谷或雅加达的日资企业员工和当地富裕阶层对正宗日料的需求。他带着积蓄，在当地开一家小而精的居酒屋或拉面店，从日本进口关键食材，严格复制日式烹饪与待客之道，靠 “正宗” 招牌站稳脚跟

另一种方式，类似今天的 “跨境电商”。例如，一位熟悉日本消费品市场的主妇或上班族，发现中国富裕家庭开始追求高品质日货。她小批量采购日本母婴产品（如尿不湿、奶粉）、美妆（如 SK - II）、家电（如虎牌电饭煲），通过早期电商平台或线下渠道销售，赚取差价

（3）投资出海

投资出海，更多是通过海外金融产品和不动产实现。这也是当下国内投资者常见的模式 —— 身在国内，投资全球

典型的例子是，一个普通的东京上班族，看到国内利率近乎为零，股市低迷。他将每年的一部分奖金投入到银行或证券公司推荐的 “国际分散投资” 基金中。这些基金专门投资于正在增长的海外市场（尤其是东南亚和美国）的股票和债券，让他能间接分享海外经济增长的红利，实现对冲国内经济风险的目的

实际上，有一个诞生于日本的概念，精准描述了这一现象 —— 渡边太太：指的是以进行借贷利率低的日圆，兑换成外币后向海外高利资产投资做为理财持家手段的炒汇散户，渡边是一个常见的日本姓氏，里面有有一大部分炒汇散户为家庭主妇，《经济学人》便以渡边太太来称呼这些进行外汇操作的个人投资者

这其中，蕴含着一个核心理念：在通胀国挣钱，在通缩国花钱。这个理念时至今日其实也不过时

在这个问题里《北京土著中产要润么？》，有回答提到了相似的理念

如果回到 1990 的日本，东京土著中产要润吗？卷又卷不过，躺平不甘心，重启人生不确定性太强。靠长辈托举，在东京衣食无忧，到底要不要润到欧美、加拿大和澳大利亚？
正确回答是：把东京的资产卖了，换成美元资产进行投资，然后继续生活在日本，东京大阪名古屋，自己爱住哪住哪。投资海外，生活日本。即使搬去北海道夕张都没事，人跑光了和你又有什么关系
以上策略后来被总结成一个经济学术语：渡边太太。至于那些觉得日本能走出通缩，死扛不卖，投资日本固定资产的，在 30 年以后日本终于开始走出通缩时，已经熬成老头老太太，成功过上了生活费不足需要继续工作的退休生活，被东大人挂在网上嘲笑
以上策略过去 30 年回测适用于东京。至于能不能用在北京，你自己考虑。你们都可以拿来回测一下当年的东京中产，看看策略能不能跑通。我们做金融的一般来说有个原则：回测跑通的策略不一定对，但是跑不通的那些直接 pass

出海这一站，我们身在何处

观察当下中国，与 90 年代初的日本宏观环境，会发现对于普通人的影响因素高度相似

人口因素上，虽总人口下降，但适龄劳动人口尚未减少，简单说，就是岗位少了，干活的人却没少。就业市场上，房地产与消费均陷低迷，原吸纳大量就业的行业普遍收缩。外部环境上，90 年代日本同样面临与美国贸易摩擦，出口受限

前述大和证券统计显示，日本上市公司海外利润近总利润 60%，多家龙头海外收入超 75%。反观中国，2023 年上半年，中国境内上市公司海外总利润 3398 亿元，仅占 8.8%。这表明当前中国上市公司高度依赖国内市场。若能实现全民出海，海外利润端或有 5 倍以上增长空间，进而将海外利润增长转化为经济承压期的新动能。我国倡导全球贸易与一带一路，也正是鼓励中国企业出海

从 2021 年开始，中国就进一步加大了对越南的投资，在视频《【全球经济】为何 2023 越南经济增速下滑欧美撤资中国加仓越南为何选择与中国修补关系》里提到了这个现象。中国此轮加大越南投资，主要是 > 换取越南内需市场，以及利用越南劳动力优势的三角循环，另外也是希望中国的品牌进入到亚非拉国家的民众心智中，实现早期的心智占领，从而为后续占领这些国家的市场打下基础。这套逻辑跟前面的提到的日本在东南亚尤其是中国出海投资的逻辑类似：以市场和技术驱动为主，需要同时从新兴经济体获取利润以及和欧美企业进行竞争

尽管 2018 年后因贸易战等因素，上一轮出海热戛然而止。但根据普华永道的统计，2023 年中国民营企业的海外并购市场结束了连续 3 年的下滑，并购额触底反弹重新回到 120 亿美元大关。虽然 2018 年以后，因为众所周知的各种因素叠加，上一轮出海热戛然而止。但随着 2023 年以后，以比亚迪与阳光电源等新能源企业出海为起点，产业资本成为了这一轮出海热的先驱。而在2024 年，我国上市公司海外收入在去年已经两位数增长的情况下，再次出现近10% 的增长，历史上首次突破 10 万亿收入大关，海外已经能占到总收入的13.8%。与海外市场高歌猛进不同，国内市场则呈现持续低迷，2024 年上市公司国内收入出现 10 年来首次负增长。目前我国境内外收入增长差已经接近 10%，非常接近日本当年全面出海潮启动的指标

随着企业出海的加速，必将带动的是国内人才向海外流动的加速

若以日本为参照，伴随 2023 年中国新一轮企业出海潮开启，我国普通人的出海机遇期也已到来。以美世与领英的报告为参考，2015 年至今，中国外派岗位数量增长约 640%，2023 年更增长近一倍。可以说，中国普通人正面临工作出海的机遇。截至 2023 年，中国财富 500 强企业中，91% 拥有不同形式的海外业务。据统计，中国已有 5.9 万家企业开展出海招聘，近两年岗位数量呈爆发式增长，领英预计到 2026 年，中国海外招聘岗位将达 450 万个

分行业看，新能源车行业是近两年出海招聘岗位增长最多的领域，增幅达 412%。互联网与消费电子行业紧随其后。以游戏赛道为例，因东南亚和拉美人口基数大、获客成本低，其海外游戏利润率通常高出国内 30% 以上，而高利润率往往意味着高收入。可以说，在新能源车、互联网与消费电子这三个领域，是否出海工作已非判断题，而是一道人生的选择题

除了行业，具体岗位需求也有了较大的变化

不同于过去 10年中海外招聘主要以销售为主的固有印象。根据美世的报告，海外企业对于运营岗位的需求开始变的更加强烈，因部分早期出海企业已具备一定市场基础，经营开始向本土化与再国际化深化，此过程需大量运营人才支撑。如何培育足够多的运营人才维系已开拓的海外市场，成为许多企业新阶段的出海难题

日本在进入到 1998 年以后，其出海行业也逐渐转向多元化。在这个过程中，日本有两类人极大的受益：第一类是在多元化转型初期就进入到海外市场的从业者，通过将日本的经营模式与本土化进行结合，利用当时日本强大的供应链从而快速形成成本效应，由此赚到了丰厚的加工利润并进行产业升级–90 年代末的日本制造业企业出海基本都是这个路子。第二类则是在 2000 年以后通过不断进行本土化改造，将日本产品彻底中国化的各类企业，这其中即包括丰田，也包括无印良品等零售企业海外从业者，一般称之为日本的品牌出海企业

日本的这两类人，恰与 2023 年中国出海人才的需求画像开始重叠。一方面，我们的新能源、电子类企业开始大规模海外设厂，海外技术类工程师紧缺；另一方面，前述海外运营人才紧缺，正是海外企业深化本土化改造所催生的需求。据霞光智库报告，2024 年我国出海招聘岗位中，对本科以上学历要求占 86%，要求工作 5 年以上岗位超一半。企业对人才要求如此之高，是因部分中国企业已进入深度本土化运营时期，急需高学历人才支援，而非简单劳务工种

但根据统计，超过一半的企业都表示海外人才招聘十分困难。主要原因之一是目前多数 30 岁以上的从业者较难接受出海工作，该年龄段出海意愿普遍低于 40%，且年龄越大意愿越低。家庭因素与水土不服是两大主因。另一方面，95 后出海意愿断崖式领先所有年龄段，多家机构统计其意向度超 75%。以猎聘海外岗位投递数据为例，95 后群体投递次数是全年龄段平均的 4 倍

这就引发了一个有趣的人才倒金字塔现象：尽管多数出海企业在问卷中表示希望招聘 5 年以上、具国际视野的复合型人才，但因早期合适应聘者太少，企业只能先招聘 95 后慢慢培养。随后几年，因这些企业快速发展，早期培养的 95 后反而成为最快具备国际化视野的群体。目前，在海外人才市场中，95 后是所有年龄段占比最高群体，在互联网等新兴行业占比超 60%，90 后占比超 82%。可以说，30 岁以下年轻人吃到了中国近几年互联网出海的第一波红利

虽然说了这么多出海的潜在益处，但是不得不承认的是，当下全球的复杂形式也给中国未来的出海之路带来了阻碍。比如说美国的各种贸易战、关税战。然而，或许就如中国经济这40年崛起之路一样，道路是曲折的，但前途也是光明的。毕竟，日韩在其全面出海之路上，亦曾遭遇不同国家的打压。但中国出海浪潮的趋势应不会改变，产业与文化双出海的战略机遇期，将配合 “一带一路”，成为我国未来二十年新的巨大红利。而这一红利，往往将献给最先行动的勇敢者。毕竟，若已是确定无疑的机会，又怎会轻易落到普通人手中？

选择与努力

都说选择大于努力；我们身边总不缺少 “人生赢家” 的故事，故事的版本往往类似：在关键时刻做出了一个 “英明” 的决定，于是乎就享受了时代的红利，从此顺风顺水，功成名就。这很容易让我们产生一种感觉：存在一个 “好选择”，一旦选中，人生就能开启简单模式

那什么样的选择才叫做好选择？什么样的努力才叫做有意义的努力？而在出海这个问题上，选择和努力又应该如何权衡？

什么样的选择才叫做好选择

什么样的选择才叫做好选择？比如说在 2008 年入大 A 然后 2016年清仓？比如说用卖出的钱买入房市和比特币并在 2021 年出？比如说在 2016年加入字节跳动然后把期权比例要满并且持着不卖？

亲爱的，这不叫好选择，这叫做好运气，或者说好梦（白日梦的梦）。在真实生活的选择里，我们无法拿着后视镜去踩中每一个风口和好趋势。而且盈亏同源、祸福相依，当前的后视镜看到的上行期的美，在另一个平行宇宙里，也许就是下行期的痛了

赌博也许算选择频次最高的行为之一了，一盘接着一盘，买定离手，需要在短时间做出选择，然后或赢或输，再开启下一盘。我很喜欢于宙的这篇演讲里《我们这一代人的困惑》关于赌博、或者说 “选择” 的故事

上大学的时候，我热衷于各式各样的赌博游戏，是学校旁边赌场的常客。我赌徒生涯的起点源于赌场里最基本游戏轮盘赌，轮盘上1 到 36 个数字和两个 0，赔率是 1 赔 36。1 到 36分为红黑两色，押注红黑的赔率是 1 赔 1
作为一个合格的接受过九年义务教育的人都知道，每一次轮盘开始转动的那一刻，都是一次纯粹的独立随机事件。但是赌博这件事情的魅力就在于，当你真正身处赌场，看到已经连续4次开出红色的时候，几乎所有人都会想把筹码压在黑色的那一面。而我当时的梦想，就是破译这其中的奥秘
我最初的策略非常简单，当连续三次开出奇数，就押注偶数，连续三次红色，就押注黑色。难以置信的事情发生了，在我严格地执行这个策略的情况下，前几次去赌场不但全身而退，每次都还赚了不少，以至于我产生了一种幻觉，也许游戏是有规律可循的，我已经看到了人生巅峰就在不远处向我招手。当然最终的结尾你们一定想到了，在经历过连续18 个偶数，连续开出 21 次黑色后，我把之前赚到的钱都乖乖地还给了赌场
后来我知道，我那个愚蠢的梦想叫做赌徒谬论，就不具体展开讲了。但它对我意义深刻，我终于明白了在纯粹的随机事件面前，一切规律都是无谓的

我们生活中遇到的所有事情基本可以分为三类，第一类纯粹由随机性决定，比如布朗运动和轮盘赌博；第二类纯粹由能力决定，比如英语六级考试、110米栏之类；第三类，也是我们最常遇到的，由能力和随机性共同决定，比如创业、投资、恋爱或是梦想

当我们回头去看，那些看似有规律可循的 “机会”，其核心充满了随机性。一个选择在当下看来是 “好” 是 “坏，往往不取决于选择本身，而取决于它背后那套由能力和随机性共同作用的复杂系统

如果说 “一命二运三风水”、“生死有命，富贵在天”，在随机性面前我们确实会无能为力，如果是这样，那什么样的选择才是 “好选择”？

也许，当你能够清晰认知到所作出的决策里，随机性占比有多高，这就是一个 “好选择”。当你有这种清晰的认知后，你才不会把所有的希望都寄托于运气，也不会在失败后，完全归咎于自己 “选择失误”。就像你决定是否要All In去闯荡演艺圈，你得明白，黄渤的成功里实力固然重要，但那万里挑一的运气，可能才是决定性的。认识到这一点，你才能心平气和地接受任何一种结果。而一个人在年轻的时候，做的每一件事情，能清楚地区分其中随机性所占的比例并能心平气和地接受它，也许就是最宝贵的财富

人类的大脑中有一个名为 “杏仁核”的器官，主要帮助我们应对生活中的危机事件，所以对 “坏消息” 极其敏感，坏消息也更容易让我们感同身受。在必要时，杏仁核可以救命。但是在日常生活中，我们也很容易被“杏仁核” 挟持，让我们倾向于只看到负面消息，同时做出灾难化想象

选择、或者说随机性，往往会让人恐惧，其原因是只看到了负面部分。但我们需要记住不确定性是两面的，同时决定了上行风险与下行风险。我们很容易过于在乎「下行风险」，以至于忘记自己完全有能力、有可能做出更好的结果

所以，也许一个好选择，是你能同时看到随机性带来的上限和下限的选择，去看数据、看事实，从数据和第一性原理出发去判断一件事情的好坏，而不是原始的恐惧情绪

那当外部有很多负面的声音的时候，我们又应该如何应对呢？《钝感力》这本书有一句笔者比较喜欢的话

在人缺乏自信或犹豫不决的时候，无论怎样的左思右想都于事无补。因此在这种时候，就要摒弃杂念，更为大胆、充满自信地向前迈进才行。
犹豫不决，不仅根本无法前行一步，还有可能往后倒退。对于你的犹豫不决，很多人当然会有他们各自的看法。而这时，我们要做的就是从中选出自己听起来最为顺耳，最能够使自己振作并快乐地努力下去的话语，从而坚定不移地向前迈进

虽然上面说的都是有点偏心态层面有点虚，但这的确非常重要，至少不会让你在某一次结果不如人意之后怨天尤人，失去做下一次选择的勇气和持续向前的魄力。在我们心里能接受随机性把我们置于最差的结果后，也许我们能开始尝试 “预测和计算” 每个选择的优劣了

从统计学的角度，每次选择的期望是可以形式化演算出来的，以最简单的压大小为例。如果本金是$a$，胜出后得到的总奖金是 $b$ ($b \gta$)，胜率是 $p$，那这这选择收益的期望就是

\[E = p*(b-a) - (1-p) * a = pb -a\]

只要保证这个期望为正，那根据大数定律，在重复多次的试验中，实际的收益的均值就会趋近这个期望

但生活的奇妙之处在于，一是我们是没法知道那个分布的，也就是上面 $p$的这个值我们是无从得知的，而且每次选择都是不同分布的。二是生活中绝大部分的选择是没法像大数定律那样，可以重复抛硬币去让最终平均收益逼近期望收益

即便如此，在我们每一次的选择里，可以尝试问一下自己这几个问题：我们关注的收益有哪几方面（健康、金钱、技能等）？我们 “赢” 的概率（能获取到这部分的收益的概率）有多大？如果我们 “输” 了，损失的东西我们是否能接受的？而在这个选择 “赢” 的概率中，随机性又扮演了大的角色？

这些问题也许不能很好做量化，甚至做量纲对齐本身就是一个比较千人千面的答案。但也许当我们能够对自己诚实，去一遍遍的询问拥有着 “一颗不断强大的大脑和一颗充满恐惧、贪欲和脆弱的玻璃心” 的自我时，也许我们就能知道哪些是当下对你最重要的是什么；也许我们就能够学会理解和接受人生的偶然性；也许我们就能允许自己恐惧，因为未知自然让人恐惧，这是你心灵的自然反应；也许我们就可以相信：每个人都有一条路，这条路有很多错综复杂的因素促成，但一定由一个人在当时当地能够做的最好的选择组成。所以你提前恐慌或者不恐慌，并不能改变什么。走上去以后，就好好地走，才能精彩

什么样的努力才叫做有意义的努力

既然生活充满着随机性和不确定性，没有绝对的 “好选择”，那该朝着哪个方向努力？还有什么事情值得努力？或者说什么样的努力才叫有意义的努力

这里我还是想借用《我们这一代人的困惑》里的例子，因为实在是写得非常好

去年这个时候，我和朋友在琢磨去大庆做点服装生意，决定去考察几个商场。我当时住在北京，因为之前晚上和朋友在外面玩得比较尽兴，回到家里已经比较晚了，担心睡觉睡过头会错过航班，那晚上就直接在沙发上靠了一晚。那是我第一次去哈尔滨，十一月份已经很冷了，衣服拿得不足，下了飞机冻得头疼。又因为没有提前订票，到了哈尔滨之后才买的火车票，发现就只剩站票了。于是，当我一晚上没睡，冻得头晕眼花，又在绿皮火车上站了两个多小时之后，抵达大庆的那一瞬间我觉得自己实在是太不容易了，将来必须要写进回忆录里面。可是，回头仔细一想，这些所谓的“努力”对我最终把那个服装生意做好，没有半毛钱关系。更何况，如果我前一天晚上能早点上床睡觉，多准备点衣服，提前在网上把火车票订好，完全可以舒舒服服地达到同样的目的
我的那次经历像是自己二十多年生活中很多事情的缩影，沉溺在对结果没有直接帮助只是因为自己遭受了一些痛苦的行为中，误以为那就是努力
当我终于意识到我并不是唯一曾经把无意义的消耗当作努力的时候，忽然发现，原来生活中我觉得很努力的人，也许没那么勤奋，如果在正确的方向上坚持行动，超过他们也并不困难

我们这一代人对于勤奋和努力的理解，几乎清一色地来自于学校，更精确地说，在前二十多年的生活中，我们眼中最努力的人，就是那些最能拼命看书和做题的人。实际上，这种理解是极其片面而幼稚的，因为看书和做题本身，都是为了一个极其鲜明的目的而存在的，就是通过考试。这种勤奋的付出极其纯粹，更多的复习时间，更高的复习强度，一般而言，都可以直接地提高考试的分数

但生活的美妙之处却在于，很多事情在我们没做到一定程度之前，是完全没法理解的。生活很多事情的回报曲线往往是非线性的，需要经过漫长的潜伏和积累，才会有质的突破。就好像作者在演讲里提到的学英语的例子

这就好比学英语，十几年漫长的岁月里我都在幻想，要通过多么复杂的流程，多么精密的设计，多么全面的涉及和多么不可思议的努力，终于有那么一天，或许我就能因为前期的那些无懈可击的学习，说一口比较流利的英语，像说中文一样，可以边说边想，而不是说每一句话之前设计它的句式时态词汇然后在心里复述几遍再看上去流利地背诵出来。谁不是这么设想的呢？可惜，它不仅从来没有实现，并且让我看不到有任何实现的趋势，对于每一个设立目标的人来说，没有比这更痛苦的感受。
但是在去了美国两年左右的时间之后，我忽然发现自己已经可以毫无障碍地说一口流利的英语了。这并非我采用了什么新的学习方法，而是因为去了印第安纳之后身边中国人很少，在没有选择的情况下，只能被迫用英语去交流和表达，在这个过程中，我并没有认真想过自己每天进步了多少，也没有阶段性的检验学习效果，只是不停地去听和说，因为没有选择嘛。直到两年多后的忽然有一天我才意识到，咦，自己好像真的已经可以了。但是我确实无法总结出来是如何一步一步做到的，只是那两年的时间，我一直都在很不情愿地用英语去生活嘛。

一个人能获得的最可贵的能力，也许和掌握一门语言一样。你所付出的努力不是能够获得即时回馈的，甚至在很长的一段时间内没有任何收获，直到积累到了一定的阶段后，忽然爆发出惊人的力量，连你自己都不清楚这一切是如何发生的

当你经历了足够多的量变后引起质变时所拥有的技能，大部分人是终身难以企及的，不是因为他们太笨，恰恰相反，因为他们都太聪明了。触发人类行动的最基本原理被称为反射，我们是需要即时回馈的物种。所以绝大多数人对于世界的理解度是线性的，但更多情况下，事物却是以漫长的潜伏震荡后爆发突破的形式发展的，比如说学习语言、读书写作、锻炼身体

那回到最开始的问题，什么样的努力才是有意义的努力？

我想在离开学校之后，在现实生活中，当我们遇到的很多事情不再像做题和考试之间联系得那么紧密时，当付出和结果之间往往没有那么立竿见影时，很多人的付出都是浅尝辄止时，而最可贵、最有意义的努力，也许是在基于上面反复询问自己内心后而做出的 “正确” 方向上，对那些无法立即获得回报的事情，依然能付出十年如一日的专注和热情。最终的结果也许不足以让你独孤求败，但足以出类拔萃

出海中的选择与努力

说到 “出海”，无论是留学还是工作，这大概是当代很多年轻人面临的最典型、也最纠结的选择之一了。它完美地融合了能力、随机性、梦想和现实的冰冷计算

我们很容易被两种极端叙事裹挟：一种是 “出海即天堂”，描绘了一幅远离内卷、高薪自由的生活图景；另一种是 “出海即深渊”，充斥着文化隔阂、玻璃天花板和难以言说的孤独。这两种叙事都像轮盘赌上连续开出的红与黑，让我们产生一种错觉，仿佛押中颜色就能决定命运

但正如我们前面讨论的，一个 “好选择” 不是去赌一个绝对正确的答案，而是基于多维度期望值的理性计算。我们可以尝试用 “期望值” 模型来掂量一下 “出海” 这个选择

我们不能只盯着一个维度的得失，得把几个关键维度打包在一起算个总账，比如说对于笔者，健康、金钱、体验多样性、复利性是几个重要的维度

健康

健康是所有 0 前面的那个 1，没有了健康，其他一切都没有意义；而成功的道路有很多，但没有任何一条是必须要以健康为代价的

很多人出海的理由是国内太 “卷” 了，为了不让过高强度的工作影响到身体的健康而选择去海外。但工作过的朋友都知道，不同团队或部门的工作强度的方差极大；虽然都叫出海，但去到哪个公司，哪个部门，哪个团队，会极大影响你实际的工作强度，所以在选择前，需要做好背调

此外，你需要评估自己能否承受异国他乡的孤独、文化冲击带来的长期心理压力。有些人天性喜欢新鲜事物，社交能力强，那这个选择的健康期望值就是正的；反之，对于一个极其恋家、内心脆弱的人，强行出海可能意味着巨大的身心健康损耗

金钱

这里需要算两笔账。一是直接的成本和收益，学费、生活成本与未来可能收入之间的概率。别光看 “华尔街高薪” 或 “硅谷大包” 这种小概率事件，也得算算找不到工作、或者只能找到一份普通工作的概率和收益。二是个人的宏观策略，其实就是前面提到的 “通胀国攒钱，通缩国花钱” 的概念；这个回答针对这一点也给出了一些观点

所谓生活、所谓移民，就是一个赚钱、一个花钱问题，这俩问题不解决其他都是次要
你问题中没谈美国，但我最熟美国，先拿它举例：美国物价最高、移民难度最高最折腾、而且这国家细想也很奇葩，但移民来的最多尤其中国人和印度人。因为容易赚钱，对就因为容易赚钱这么简单就这一个因素，导致美国最大的优势是即使有一天不想在这住了随便去世界哪里都觉得便宜，带着攒的钱跑路去哪里不是吃香喝辣
我个人认为，如果类比起来：中国三线城市之于北京，便如北京之于美国 —— 消费低、通缩等
按 “渡边太太” 理论，确实更好的策略是：钱出去，人留下，钱跟着通胀去，人享受通缩去
说得简单点，人生需要钱时要卷起来时，去通胀国/地区打工；人生开始走下坡路准备退场时，已有的资源就得加倍呵护因为是 “有限资源”，回通缩国/地区消费

体验多样性

这一点上，“出海” 绝对能给你提供一种全新的体验，你被迫用另一种语言生活，理解另一套社会规则和新的文化，也许让你看到，生活不止一种活法。这种价值，无法用短期金钱衡量。却能在你出海期间，甚至未来几十年的人生里，提供看问题的不同角度和解决问题的不同思路。这种体验本身就是一张未来可以兑换其他机会的彩票

生活，最终还是活的一个体验的多样性。可以问一下自己，当前的这一次出海的机会如果放弃了，后续是否还会再有？到那时候对自己而言，是否还会是一个出去的好时机？如果都没有这样的机会，10年后自己会后悔当初的这个抉择么？

复利性

如果说中国的企业出海是未来，那未来大量的岗位必然对语言甚至海外经历有一定的要求。如果这个趋势是必不可挡的，那最好的选择也许是及早拥抱这个趋势

抓住这个 “没有选择” 的环境，去真正掌握语言、建立跨文化的适应能力、构建在全球范围内都具备竞争力的专业技能，那么这种能力就是带复利的。它能在你未来的人生里，像滚雪球一样，持续带来新的机会和增长

但如果你只是去混个文凭或者只是赚两年的快钱，把自己封闭在华人圈子里，重复国内的生活模式，那复利效应很弱

那么，努力在出海里又扮演什么角色？

当你基于这个模型，做出了出海的选择后，努力的方向就变得无比清晰：你的所有努力，都应该服务于最大化这个选择中具有复利效应和体验价值的维度，同时管理好健康和金钱维度的风险

需要谨记的是，你的努力不是去赌场里试图破译轮盘的规律 —— 比如幻想靠一次投机就能实现阶层跃迁。而是要最大化你能力的概率，让你成为那个在 “能力和随机性共同决定” 的游戏中，能力占比更高的人

你的努力，是清晰地认识到 “通胀国攒钱” 的阶段目标。在这个阶段，你需要的是卷起来，是把你的专业技能和汗水，高效率地兑换成未来的筹码和选择权。此时的辛苦，如果是指向明确的能力提升和资本积累，那就是有意义的努力

你的努力，是构建你的 “复利引擎”。学好语言，建立有价值的专业网络，培养跨文化解决问题的能力。这些能力，无论你未来是选择继续留在 “通胀国”，还是带着筹码去 “通缩国” 享受生活，都是你赖以生存和发展的根本

你的努力，是主动跳出舒适区，去最大化 “体验多样性”。不是把自己活成一个孤岛，而是强迫自己去和当地人交流，去理解他们的文化，去参加那些看起来 “没什么用” 的社交活动。这正是在为你未来的 “选项价值” 充值

这是个需要花力气做出改变的过程，过程中必然是会有痛苦的。但人生嘛，宁吃自己的苦，不吃生活的苦。有得选的时候尽量做选择，虽然苦点累点，不要没得选了开始内耗。比如选读书的苦，不选无业的苦；选运动的苦，不选生病的苦

没有弯路

虽然《杀鹌鹑的少女》把选择这个命题描述的比较沉重，但真的是所有选择都会影响巨大么？我们没法回答这个问题，因为 “未选择的道路” 就如同反事实数据一样，我们永远无法得知那条未选择之路的好坏，虽然我们常常会去美化这条所未曾选择的道路，然后觉得自己走了 “弯路”

这种选择的沉重感，归根结底是源于三件事：

（1）人生的有限性。“我走这条路是不是多浪费一两年的时间？”“我会不会走弯路？”这是人生的有限性在摆弄你
（2）未来的不确定性。“我要如何准备才能胜出？”“我会失败吗？”这是未来的不确定性在你的内心敲打
（3）过去的不可更改性。“我的选择是不是错了？”“这么大的投入最后回报得来吗？”，你们患得患失，因为没有后悔药可以吃。

我们之所以在选择的时候有这些焦虑、恐慌、敏感的情绪，害怕走 “弯路”，很多时候就是源于这三个因素。但吊诡之处在于，如果你感到的恐惧是由人生某些不可改变的特点带来的，那么即使你拼命想抓住写什么，甚至于你终于完成了一个目标、得到了一块暂时的喘息之地，你仍然无法解决内心的痛苦

这也许就是我们这一生都在实现目标中挣扎着度过的原因：上初中的时候，老师告诉你，中考的淘汰率是最高的，只要闯过去，上了高中一切就好了。但上了高中的时候，高中老师又说了，考上大学就进了天堂。当你考上了大学，依然空虚迷茫，父母老师又告诉你，找到工作就好了。工作之后发现烦恼和忧虑依然都在，大家都告诉你等你事业有成就好了……

我们这一生似乎都在试图让自己走在社会告诉我们的 “正道” 上，少走 “弯路” 是朋友、老师、父母告诫我们要避免的，可是，这个 “弯路” 又该怎么定义？排除掉那些明显不合法的伤害他人、伤害自己的行为，又有多少的路是真正的 “弯路”

每每这时，我都会想起 Steve Jobs 的那个我非常喜欢的 connect the dots的故事，虽然已经是 20 年前的演讲，但我一直奉为圭臬，每次重听也总能激励到我

None of this had even a hope of any practical application in my life.But ten years later, when we were designing the first Macintoshcomputer, it all came back to me. And we designed it all into the Mac.It was the first computer with beautiful typography. If I had neverdropped in on that single course in college, the Mac would have neverhad multiple typefaces or proportionally spaced fonts.
If I had never dropped out, I would have never dropped in on thatcalligraphy class, and personal computers might not have the wonderfultypography that they do. Of course, it was impossible to connect thedots looking forward when I was in college. But it was very, very clearlooking backwards, ten years later.
Again, you can’t connect the dots looking forward. You canonly connect them looking backwards, so you have to trust that the dotswill somehow connect in your future.You have to trust in something: yourgut, destiny, life, karma, whatever. Because believing that the dotswill connect down the road will give you the confidence to follow yourheart, even when it leads you off the well-worn path. And that will makeall the difference.

事实上，真正的人生不是一场竞赛；至少也不是一场跑向同一终点的竞赛。那条笔直的、被无数人验证过的 “跑道”，其实是高考给我们养成的思维惯性。一旦进入大学、迈入社会，这套逻辑就渐渐失灵了

如果你去读大多数成就一番事业之人的传记，会发现他们的人生轨迹，极少是一条昂扬向上的直线，反而充满了意想不到的波折与迂回，有的甚至是几起几落

比如说比如说奥巴马和克林顿都是穷小子，好不容易考上了个东部的常青藤，结果毕业后一个回老家干社区工作，一个回老家在名不见经传的大学教书；比如说如今被誉为 “寿司之神” 的小野二郎，年轻时曾在市场鱼贩那里做了多年的学徒，每天只是处理鱼货、打扫卫生；比如说爱因斯坦在提出划时代的相对论时，只是瑞士专利局里一个默默无闻的三级技术员。他的研究工作与他的本职工作几乎毫无关系，完全是在 “业余时间” 进行的。按照前面的逻辑，他们都 “走了弯路”

可是从后往前看，哪里又有什么弯路？

你当过社区工作者，深入了解了基层的脉搏与民众的真实诉求，这份独特的阅历，是那些直接进入精英机构的同学所没有的。几十年后，当你需要展现对民生的深刻理解与共情能力时，这就成了你无可替代的优势；你曾在鱼市里磨砺过，对每一种食材的时令、质地、处理方法了如指掌。几十年后，当你追求极致的料理时，这段经历便化作了你区别于所有厨师的、最深厚的底蕴；你在专利局里安静地演算，避开了学术界的浮躁与成见。恰恰是这份 “孤独”，保护了你最颠覆性的思想得以孕育成型

当你从后往前看，把人生的点连成线，会发现所有的努力和经历都不会白费，在哪个领域、哪个岗位努力都可能在未来产生回响。那些看似八竿子打不着的知识和技能，不知在哪个命运的拐角，就会悄然融合，迸发出惊人的力量

当你从后往前看，你会发现，真正的弯路从来不是哪一次具体的方向选择，而是内心的怨天尤人与行动上的停滞不前。是那种不断回头张望、懊悔 “如果当初”，却让 “现在” 和 “未来” 在无尽的内耗中白白流逝的状态

人生的路，不是规划出来的直线，而是一步步走出来的轨迹。

我很喜欢这句话：“没有什么事情或节点，能把我们的人生分成两段 ”

我们总是不自觉地给人生划分阶段，并寄望于某个里程碑之后，生活能焕然一新：考上大学就好了，找到工作就好了，结婚生子就好了，财务自由就好了…… 仿佛人生是一部可以分集的连续剧，过了某个关键情节，基调就会彻底改变

但现实是，从出生到生命尽头，生活是一条连绵不绝的河流。它不会因为你拿到了某个学位、某份聘书，或戴上了某枚戒指，就从湍急变得平缓，从浑浊变得清澈。生活的每一个阶段都自带其独特的痛苦与焦虑，它们周而复始，只是换了一副面孔出现。你不会因为考上大学，就告别了青春的迷茫；不会因为事业有成，就消除了中年危机的阴影；更不会因为迎娶了女神，就免疫了婚姻中琐碎的摩擦与漫长的磨合

反过来，每一个阶段也镶嵌着独属于那个时期的、无法复刻的快乐。二十岁时，和兄弟们在夏夜操场打完篮球，瘫坐在场边，汗水淌进眼里有些刺痛，仰头猛灌一口冰可乐，那气泡在喉咙里炸开的简单酣畅，是你未来坐在米其林餐厅里，从容品鉴一杯复杂红酒时所无法体会的。年轻时可以为了一个灵感通宵达旦，可以来一场毫无计划、说走就走的 “特种兵” 旅行，那种由充沛精力和对世界的好奇所驱动的纯粹快乐，与中年后精心规划的、追求舒适与品味的旅行，是两种截然不同的生命体验

每一段岁月都有它存在的价值，没有高低贵贱之分，都不应该被辜负。试图用未来的某个 “黄金时代” 来否定当下的 “青铜岁月”，或者沉溺于过去的 “美好时光” 而逃避眼前的现实，都是对生命本身的浪费

因此，你要记住，没有弯路，因为“发生在你身上的事，要么是个好事，要么是个好故事”。顺利的成功，自然是 “好事”；而那些看似失败的、痛苦的经历，在事后回望，往往会沉淀为你人格的一部分，成为你酒桌上、文字里、与晚辈交谈时，那个最有力量的 “好的故事”。它定义了你的韧性，丰富了你生命的层次

当然，这话听起来，在某种程度上确实有点阿 Q 精神的嫌疑。它似乎轻描淡写地忽略了过程中真实存在的、甚至对一些人而言是生命无法承受之重的苦难

我非常喜欢《三傻宝大闹宝莱坞》这部电影，十多年前第一次看的时候被电影的观点震撼到，这次国庆重新看的时候依旧觉得获益良多，电影里有个情节是这样的

当 Raju 在对繁重学业和即将到来的期末考试而焦虑不安时，Rancho告诉他，尝试把手放到自己的胸口对自己说 “All isWell”，并说我们的心是很容易动摇的，你得学会哄它，无论遇到多大的事情都可以对自己这么说。Raju反问到 “这能解决问题么”。Rancho说并不能，但是这能够给你解决问题的勇气和决心

这句简单的 “All is Well”，和我们在播客《无人知晓》里都听到的 “咒语” 这一概念一样，它们不是解决问题的具体工具，而是一种 “心法”

比如说《此时此刻》中提到的 “刺激和回应之间存在一段距离，成长和幸福的关键就在那里”，“平静是意识到世界并非我们想象的那样”，还是《哦》中提到的“内心自我否定、攻击、怀疑，99%都是假的”、“最重要的就是走，往哪走都行”

我想，这些 “咒语” 和 “All isWell” 一样，它们或许不能像螺丝刀一样直接拧紧松动的零件，也无法像导航一样为我们规划出最优路径。但它们能为我们疲惫的心灵 “充电”，在我们踏入未知的黑暗时，像一支火把，虽不能照亮整个前程，却足以给予我们迈出下一步的勇气和决心，让我们能够轻装上阵

不确定的赌局, 与我们的下注

聊了这么多，从日本出海的宏观叙事，到个人抉择的微观权衡，我们仿佛在迷宫中绕了一大圈，最终却回到了那个最原始、也最核心的困惑前：在一个由能力、努力与巨大随机性共同主宰的世界里，我们究竟该如何自处？

回望日本出海的历程，它并非一份精心绘就的宏伟蓝图，更像是一个经济体在撞上内需天花板后，被逼出来的一种集体生存智慧。企业与个人在时代的巨浪中扑腾，摸索出 “工作、商业、投资” 三条路径，其底层逻辑出奇地一致：将自身已有的技能、资本或头脑，与海外市场更早期、更饥渴的发展阶段相嫁接，从而兑换一份 “时间差” 带来的溢价。这背后，是 “通胀国攒钱，通缩国花钱” 的冷静算计，也是对全球资源进行朴素配置的直觉

当我们把这份宏观的镜子转向自身，所谓的 “好选择”，从来不是那个能让你一劳永逸、开启人生简单模式的 “标准答案”。它更像是在信息不完备的牌局上，一次基于多维度期望值的下注。这个决策模型里，装着健康、金钱、体验的广度与能力的复利等重要的、千人千面的维度。一个 “好选择” 最关键的标志，在于你清醒地知道随机性在其中占了多大分量，并且，无论牌面如何翻转，你都能心平气和地摊开双手，接受任何结果

而 “有意义的努力”，则是在你下注之后，不再沉溺于 “没有功劳也有苦劳” 的自我感动型的无效消耗，而是将所有的行动与心力，都聚焦于一件事：如何提升我们 “赢” 的概率。它是在基于前面 “好选择” 选定的方向上，对那些无法立即兑现、甚至漫长岁月里都看似石沉大海的事情，付出持久的专注与热情。无论是被迫掌握一门语言，还是构建一个能产生复利的能力网络，其价值都在于，它们让你在这个充满随机性的牌桌上，资格更老，筹码更多，活得更久，从而能等到那场属于你的、非线性回报的爆发

那么，回到最初那个纠缠我们的迷思 —— 关于 “出海”，关于所有人生十字路口的抉择：它们究竟是那 “命运的巨变”，还是我们当时所以为的 “生命中普通的一天”？

答案是：它两者都是，它取决于你站在哪个时间点回望

站在抉择的当下，它平凡、沉闷，甚至充满了患得患失的焦虑与自我怀疑。我们惧怕 “一步错，步步错”，恐惧有限的青春被 “浪费” 在弯路上，懊悔没有吃到后视镜里清晰可见的红利；这种感受，真实而具体。但当我们走过一段，回首来路，用 “连点成线” 的眼光去审视时，每一次选择，无论当时被贴上 “正确” 或 “错误” 的标签，都深深地编织进了我们独一无二的生命纹路里，构成了无法替代的路径。你会发现，那些所谓的 “弯路”，在生命的宏观图景中，恰恰提供了最独特的风景与给养

所以，人生这场游戏，或许根本就不存在一条被社会严格定义的 “正道”，也因此没有什么绝对的 “弯路”。真正的弯路，不是你在某个路口选择了左转而非右转，而是你因为恐惧而停留在原地，不停地抱怨与内耗

就像《三傻大闹宝莱坞》里那句简单的 “All iswell”，它并不能解决实际问题，却能给你直面问题的勇气。在面对出海，或是任何人生命题时，我们最需要的，也正是这份勇气 —— 在计算之后行动的勇气，在行动中拥抱不确定性的勇气，以及在不确定性中始终相信 “发生在自己身上的事，要么是好事，要么是好的故事”

生命就在每天的生活里，不在某个遥远的、过了之后一切都会好起来的 “节点” 上。认真评估，果断下注，然后专注于打好你手中的牌

走上去，好好地走，本身就已经是一种精彩

本文一些参考资料

日本企业 “出海” 启示录| 逐潮向海
日本出海之路给我们的启示
泡沫破裂后，日本全民出海潮对普通人的借鉴
2023 年中国企业并购市场回顾与前瞻
高度内卷下，日本全民出海潮中普通人的抉择与借鉴
我们也会有如同日本一样的全民出海潮吗？
复盘中国 2024 出海之路，对比日本出海潮，我们走到了哪一步？
泡沫破裂后，日本全民出海潮中普通人的机遇
我们这一代人的困惑
写给大四
Connectthe Dots

Attention Is All You Have

2025-10-03T23:51:23.000Z

2017 年，《Attention IsAll You Need》悄然问世，带来了 Transformer的架构，这个此后被搜广推领域广泛应用、并成为后来掀起新一轮 AI 革命的 LLM的基石。Transformer让机器拥有了某种 “超级注意力”：一种可以并行处理全局信息、计算序列中所有元素关联权重的强大机制。它不需要像人类一样逐字逐句地阅读和理解，而是可以一瞬间 “看到” 全部，并找出其中最关键的连接

但是一个巨大的悖论和困境正在上演。人类创造了看似拥有 “无限可扩展注意力” 的机器，但人类自身所拥有的，却是一套古老而有限的生物注意力系统。机器的核心是 “更多、更快、更全局”，而人类的核心是 “选择、聚焦、做减法”。我们正用着自己这套需要休息、会疲劳、极易分心的心智系统，去对抗一个由 “超级注意力” 算法驱动的、旨在无限捕获我们注意力的科技环境

对于碳基生物而言，更加残酷的一个事实是” Attention Is All YouHave”。因为对人类来说，注意力是与生俱来、且每日额度恒定的核心生命资产。而这唯一的货币投向何处，你的生命就投资何处，最终也将到达何处。我们一直在说 “人是环境的产物”，究其原因，也许是人在某个环境中，不得不将其的注意力倾注到这个环境设定的规则里最关注的事情，进而决定了人将变为何种产物

如果说注意力是人最宝贵的财富，那如何保护自己的注意力便是一个值得探讨的命题。本文尝试对这部分展开一些探索，包括人的注意力为何是有限的，这少得可怜的注意力在当下的注意力经济中是如何被各种争夺，以及如何构建自己的注意力框架。本文是笔者最近感觉自我工作效率低下后的一次寻根问底求法的过程，祝开卷有益～

有限的注意力预算

看不见的大猩猩

1999 年，心理学家克里斯托弗・查布里斯和丹尼尔・西蒙斯设计了一个堪称经典的 “看不见的大猩猩”(The InvisibleGorilla) 实验。这个看似简单的实验设计，却揭示了一个令人不安的真相：我们对自己感知能力的自信，很大程度上是一种错觉

在这个实验中，参与者被要求观看一段视频，数一数身穿白色球衣的队员一共传球多少次。视频中间，一个穿着大猩猩服装的人走入镜头，捶打胸膛，然后缓缓离开。结果却令人震惊：超过一半的参与者全神贯注于计数，完全没有看到那个明显的大猩猩。而当被告知真相时，许多参与者坚决不相信，甚至怀疑实验者更换了视频。他们对自己的观察能力如此自信，以至于无法接受如此明显的事物竟从自己的意识中完全消失

这个实验生动地揭示了注意盲视（InattentionalBlindness）：当我们的注意力高度集中于某一事物时，会对其他显而易见的信息视而不见。这不是粗心，而是我们大脑信息处理能力的根本瓶颈。后续研究进一步证实，即便是飞行员、放射科医生等经过严格专业训练的人员，在专注执行特定任务时，同样会错过显而易见的关键信息。比如在一项医学影像研究中，83% 的放射科医师在寻找特定病灶时，竟未注意到图像角落处一个明显的外星人贴图

我们的注意力就像一个聚光灯，光柱之外的一切，都会沉入黑暗。大脑的前额叶皮层就像专业的灯光师，为了确保主要任务的完成质量，会有意抑制次要信息的处理

认知心理学中的有限容量理论（Limited CapacityTheory）指出，人类的注意力是一种有限的认知资源。当同时进行多项任务时，如果总需求超过资源总量，整体的表现就会下降。这个其实跟 “心智带宽” 的概念也有点像，人的注意力通道是一条带宽受限的通道，在执行一项任务时消耗的带宽越多，可用于执行其他任务的带宽就越少，从而导致整体性能下降。这通常通过双任务范式 (Dual-TaskParadigm) 的实验来证明：让参与者同时执行两项不同的任务（主任务和次任务）来研究认知负荷对任务执行能力的影响。比如一边记忆单词一边做数学题，他们的表现通常会比只做一件事时差

注意力的反向塑造

在这个信息爆炸的时代，我们每个人的注意力都成为了一种稀缺资源。但比这更深刻的真相是：注意力不仅是资源，更是一把雕刻刀。你持续关注什么，你的心智、能力甚至大脑结构，就会朝着那个方向演化；这种塑造发生在多个层面，从即时的认知表现到长期的个人发展，背后有坚实的心理学和神经科学依据

心理学家威廉・詹姆斯在《心理学原理》中提到：“我的经验是由我选择注意的东西决定的”。我们并非体验世界的全部，我们只体验我们关注的那部分。你的注意力过滤器，决定了哪些信息能进入你的意识，从而构建你的个人现实

伦敦大学学院的神经学研究显示，不同领域的专业训练会诱导特异性的脑结构改变，在这篇文献中《Navigation-relatedstructural change in the hippocampi of taxidrivers》指出，通过脑扫描研究，发现伦敦出租车司机大脑中负责空间记忆的海马体后部显著更大，因为这些司机们需要花费数年时间持续将注意力集中在记忆伦敦复杂的街道网络上。这就像健身增肌，只不过他们锻炼的是大脑中负责导航的特定区域。

类似的神经可塑性现象在不同领域的专家身上都有体现：

钢琴调音师的左侧听觉皮层灰质密度显著增高，他们的耳朵能分辨出常人无法察觉的微小音高差异
品酒师的嗅觉皮层与眶额叶皮层连接增强，能构建出复杂的风味地图
专业棋手的顶叶皮层更为活跃，能在脑海中预演数十步棋局的演变

这些结构性改变印证了 Hebbian theory中提出的” 神经元同步放电则连接增强” 原则，当你持续将注意力投入某个领域，相关神经元回路就会被反复激活，最终物理性地强化这些连接，就像小径因频繁行走而变成康庄大道

然而，这种强大的神经可塑性是一把双刃剑。哲学家尼尔・波兹曼在《娱乐至死》中发出的警告，在今天这个算法时代显得尤为紧迫：媒介的形式本身会潜移默化地塑造我们的思维方式和认知习惯

在电视时代，一切信息都必须以娱乐的方式出现，碎片化、图像化、追求瞬时刺激的特性，则塑造了浮躁和浅薄的文化。今天的我们身处一个由算法驱动的、比电视强大无数倍的超注意力捕获网络中，如果我们放任自己的注意力被无限切割、被廉价娱乐填满，我们就在主动重塑一个不利于深度思考的大脑。神经科学研究显示，持续的多任务处理和碎片化注意力会：1）强化大脑对快速反馈的依赖，削弱前额叶皮层的抑制控制能力2）减少默认模式网络的激活，而这一网络正是创造性思维和深度整合的发生地3）导致注意力残留效应，即使切换任务后，大脑仍有一部分资源被先前任务占用

如同在《工作、体制化与自由》一文中提到的，短视频带来的高频、短期的刺激，代价是词汇量、语义精度和表达能力的下降，是阅读长内容的耐心和能力的丧失，是系统性思考与推理能力的衰退，也是空虚感的重要来源

无限的注意力争夺战

在这个信息过载的时代，我们每个人的注意力都成了各方势力争夺的战场。正如经济学家赫伯特・西蒙所预言：“信息的丰富导致了注意力的贫乏”。我们正生活在这个预言的实现中，每个人的认知预算都在被精心设计的系统持续透支

注意力经济下，你才是被售卖的商品

我们每日有限的 “注意力币”，已经成为当今世界最炙手可热的商品，由此催生了 “注意力经济（Attentioneconomy）”。这个价值数千亿美元的注意力经济，其商业模式异常清晰：将用户的海量注意力聚合起来，然后 “打包” 卖给广告商。如同在《The SocialDilemma》中发出的发人深省的警告：If you’re not paying for theproduct, you are the product

这个系统的精妙之处在于，它不再是被动地等待你的关注，而是主动地捕捉你的意识。收割我们注意力的武器，正是由《AttentionIs All YouNeed》所启发的技术架构。社交媒体、短视频平台、新闻资讯 App 的背后，是复杂精密的推荐算法系统，它们的优化目标极其单纯：最大化用户停留时长和互动率。它们就像永不疲倦的角斗士，为了争夺你的 “注意力币” 而疯狂角力

这些系统巧妙地利用了人类大脑的进化弱点：

对不确定性的痴迷：下拉刷新机制与老虎机的” 可变奖励” 模式同出一辙，每一次刷新都在激活我们大脑中的多巴胺系统，创造着” 下一次会有更好内容” 的期待；如同斯金纳箱里那只不断按压开关期待得到奖赏的小白鼠一样
对负面信息的警觉：坏消息、冲突、八卦往往能获得更多点击，因为我们的生存本能要求我们时刻警惕潜在威胁
对社交认同的渴望：点赞、评论、转发的通知提示，，触发了我们大脑中与社会接纳相关的奖励回路

“无限滚动”、“自动播放”、“个性化推荐”—— 这些都不是中性的功能设计，而是精心计算的” 注意力捕获装置”。它们像是一条永不停止的传送带，让你在无意识中持续消耗着宝贵的认知预算

深度工作 vs 碎片化响应

在” 注意力经济” 的持续冲击下，我们正在丧失一种至关重要的核心能力：深度工作（DeepWork）。这其实也是计算机科学家卡尔・纽波特在同名的书籍《深度工作》中提出的概念，指的是 “在无干扰的状态下专注进行的职业活动，使个人的认知能力达到极限。这种努力能够创造新价值，提升技能，且难以复制。”如程序员编写复杂的核心代码、作家撰写书籍章节、科学家推导关键公式、设计师构思核心创意等；与之相反的是那些对认知要求不高的、逻辑性的事务性任务，通常在受到干扰的情况下开展的工作

从神经学和心理学角度出发，深度工作都是具备巨大价值的

从神经学角度出发，专注力是一种需要训练的能力。从上面的注意力反向塑造的理论可知，行为会重塑大脑，而深度工作能够强化专注相关的神经回路，从而变得更擅长专注和思考。反之，不断分心会永久性地削弱这种能力
从心理学的角度出发，深度工作中所达到的理想状态，其实这也是我们常说的心流状态 (Flow)，其特点往往是需要高度专注、创造价值、有门槛，其关键点之一是不受到外界的过多干扰。心流是幸福感、满足感和意义感的重要来源。高质量的工作生活本身就是一种巨大的回报，如果乔帮主在Stanford那场著名的演讲中的提到的一样

I’m convinced that the only thing that kept me going was that I lovedwhat I did. You’ve got to find what you love—and that is as true forwork as it is for your lovers. Your work is going to fill a large partof your life, and the only way to be truly satisfied is to do what youbelieve is great work. And the only way to do great work is to love whatyou do.

然而事实是，我们已陷入集体性的” 碎片化响应” 模式。现代工作环境几乎是与深度专注为敌的。开放式办公空间虽然促进了表面上的协作，却成了持续干扰的温床。我们不断地在邮件、即时消息、会议通知和突发请求之间疲于奔命。更恐怖的是，我们似乎默许并推崇这种” 忙碌文化”，将碎片化的响应等同于工作效率。快速回复邮件、同时处理多个任务、频繁参与会议 —— 这些行为获得了组织的即时奖励，却让我们远离了那些真正需要深度专注才能完成的价值创造工作

但从生物学的角度出发，人类大脑的构造决定了我们本质上是序列处理器，而非并行处理器。所谓的“多任务处理” 实际上是一个快速、耗能的 “任务切换” 过程，而每一次切换都伴随着显著的生物学代价（switchcost）

1）效率下降与时间浪费。虽然每次切换可能只需要十分之几秒到几秒钟来重新定向注意力，看似短暂，但在一天内成百上千次的切换中累积起来，就是个巨大的时间黑洞。另外就像一壶水每次烧到一半就关掉，重新再烧，整体煮沸的时间远大于一次性烧开

2）错误率增加与认知残留。当你从任务 A 切换到任务 B 时，关于任务 A 的思维碎片（attentionresidue）并不会立刻消失。它们会干扰你对新任务 B 的专注，导致你在 B 上犯更多错误，或者感觉思维 “粘滞”。在切换的缝隙中，大脑容易将不同任务的规则混淆。比如，你正在写邮件，然后去回了条微信，再回来写邮件时，可能会不小心把微信的缩写或表情符号用在邮件里，这就是典型的接口错误

3）加速心智疲劳与压力荷尔蒙。任务切换是一种高能耗的认知活动。每一次 “规则卸载与加载” 都需要消耗大量的葡萄糖（大脑的主要燃料）和氧气。这解释了为什么没做什么 “正经事”，只是不停回邮件、看消息，一天下来也会感觉心力交瘁 —— 你的大脑一直在进行高强度的内部搬运工作。持续的、不可预测的干扰（如 IM 软件消息、邮件）会激活大脑的“威胁监测” 网络杏仁核，引发低度的应激状态，分泌皮质醇等压力荷尔蒙。长期如此，会导致慢性疲劳、焦虑和创造力枯竭

4）对学习与长期记忆的深层损害。将短期记忆转化为长期知识，需要海马体的深度处理；深度、不受干扰的专注是这一过程的关键。频繁的任务切换会阻止信息进入深度处理流程，导致你感觉 “学了很多，但什么都没记住”。更可怕的是，长期的多任务习惯会重塑我们的大脑神经回路。它会让我们的大脑习惯于寻求新奇和刺激，变得越来越不耐受无聊和沉默。最终，当你需要长时间专注于一本复杂的书籍或一份困难的报告时，你会发现自己已经失去了这种能力 —— 你的 “专注力肌肉” 已经萎缩了

我们正在用人类本质上的串行处理大脑，去拙劣地模仿机器并行处理的” 多头注意力” 机制。Transformer 模型可以真正地同时处理多个信息流并理解其复杂关联，而人类的所谓” 多任务”，只是在浅层次事务上消耗注意力，牺牲了深度思考和创造性产出。我们试图成为机器，却在过程中丧失了身而为人的独特优势

设计你的 Transformer

在这个注意力被疯狂争夺的时代，我们需要从被动的注意力消费者转变为主动的架构师。就像Transformer模型通过精心的结构设计实现高效的信息处理，我们也需要构建属于自己的” 个人注意力架构”，从而帮助我们在信息洪流中保持清醒，将宝贵的注意力资源投入到真正重要的事物上

定义核心 Query

在 Transformer 中，Query是主动发出的提问，它决定了模型要在海量信息（Key）中寻找什么。同样，管理注意力的第一步，是向自己发出一个清晰的Query：我当下最核心的目标和价值是什么？或者用更加大白话来说，我到底要什么？

说实话要回答这个问题并不容易，知道自己要什么、想成为什么样的人、这一生要怎么过，本身就是一个极度非标的、需要花费大量时间和心力、持续做自我探索才能得到答案，又或者终其一生都没有答案的问题

虽然长期的目标不那么好定义，单独短期的目标还是相对明确的。比如说每个季度初，可以写下1-3个最重要的 “灯塔” 目标。它们应像灯塔一样，指引你所有的努力方向，这有点像的不少互联网公司的okr 制度

另外，可以定义每日的 Query清单：每天清晨起床，可以拟定下 “我的注意力最需要投注在哪三件事上？”这能帮你设定一天的注意力基调

优化 Key-Value 对

定义了 Query之后，就需要对输入的信息进行过滤和权重分配。这意味着需要强化高价值的 Key和弱化低价值的 Key

强化高价值 Key：主动寻找和增加与你的核心 Query相关的信息源。例如，如果你的 Query是 “提升专业技能”，那么专业的在线课程、行业报告、高质量的书籍就是高价值的Key。它们背后的 Value 是职业成长和核心竞争力
弱化低价值 Key：勇敢地对那些与你核心目标无关的 Key说不。这相当于在计算注意力权重时，直接给它们乘以一个接近 0的衰减系数。无关的微信群、八卦新闻 App、无尽的推送通知，都应被纳入此列

这需要我们对输入信息进行权重分配，建立一个精密的过滤系统。实战中有一个分级过滤策略值得尝试（其中不少理念出自上面的《深度工作》这本书）

第一层：环境级过滤

卸载那些最消耗你时间的娱乐应用（尤其是短视频和社交媒体 App）。或者可以只在电脑端使用它们，增加使用门槛
减少用网络来消磨碎片时间：排队、等车时不要立刻刷手机获取碎片化，这会让你的大脑习惯于这种 “分心” 的模式。可以做一些连续性强的事情，如听播客
关闭所有非关键通知，只保留电话、短信和极少数重要通讯工具的通知，减少这些信息对你的中断
使用 Freedom、Cold Turkey 等工具在工作时段屏蔽干扰网站

第二层：内容级过滤

取消关注那些让你焦虑、或总是推送无用信息的公众号、博主和邮件列表
订阅 2-3 个高质量的输入信息源，关注少数几个领域内的顶尖专家，而不是被算法推荐牵着走
建立” 信息食谱” 概念：蛋白质（深度内容）、维生素（跨界知识）、碳水化合物（日常资讯）

第三层：时间级过滤

设定固定的工作时间，如每天在固定时间进行深度工作，形成一种习惯和节奏；设定固定的信息处理时段，比如上午 10-11 点处理邮件和企业IM 的消息
晚间 10 点后启动” 数字宵禁”，停止处理工作信息
每周日上午进行” 信息斋戒”，通过冥想等方式给大脑留出消化的时间和空间

“Multi-Head” 策略

Transformer 的多头注意力（Multi-HeadAttention）机制，真正在硬件层面同步计算多个注意力函数，然后将结果拼接融合，它的每个head 都拥有独立的计算资源，来并行捕捉信息的不同方面

但对人类而言，如果前面提到，人类大脑的构造决定了我们本质上是序列处理器，而非并行处理器。所谓的 “多任务” 只是快速切换，并付出巨大的切换成本 —— 包括时间延迟、错误率增加和心智疲劳等

因此，我们的策略不是成为机器，而是向机器学习其架构的 “专注” 与 “模块化” 思想，通过极致的规划，在时间线上模拟出并行的效果，从而最大化我们串行处理器的效能。如果我们把注意力模块化地分配，可以粗略将注意力划分为4 种重要的 head：深度工作、日常事务、创意探索和恢复休息

“深度工作” 头

进入深度工作状态，本质是触发 “心流”(FLow)。心流状态下，大脑会释放去甲肾上腺素、多巴胺、内啡肽等神经化学物质，这些物质不仅能提升幸福感，还能显著增强专注力、模式识别能力和创造性思维。这是一种一旦中断就难以重建的高价值状态。

进入深度工作状态有一些可尝试的建议

1）设定启动仪式：在深度时间块开始前，进行一个简单的仪式（如泡一杯茶、整理桌面、深呼吸三次），告诉大脑 “准备进入状态了”。这能形成强大的条件反射

2）明确产出目标：不要只写 “写报告”，而是写 “完成报告引言部分和三个核心论点的初稿”。具体的目标能牢牢锁住你的注意力

3）环境设计：工作台极简主义，即保持桌面整洁，只留下当前任务所需的物品。多余的物品都是视觉上的干扰源；噪音管理，环境嘈杂下使用降噪耳机，播放白噪音、自然声音或专注音乐（如 Lo-fi），隔绝auditorydistraction

4）番茄工作法：对于难以进入深度状态的人，可以从 25 分钟专注 + 5 分钟休息的 “番茄钟” 开始训练。当你深度工作能力增强后，可以尝试延长专注时间至 50 分钟或 90 分钟

“日常事务” 头

如同前面提到的 “注意力残留” 效应，当你从一项未完成的任务切换到另一项时，你的注意力资源并不会立刻完全转移，一部分会 “残留” 在之前的任务上。而批量处理琐事，就是为了将这些残留效应集中并最小化，避免它们污染你的深度工作时间

具体的建议，可以安排 1-2 个固定时间（如上午 11 点，下午 4 点），批量处理邮件、回复消息、报销等琐碎事务。其他时间绝不查看；同时也为这个时间块设置一个倒计时（如 45 分钟）。时间压力会迫使你更快地决策和行动，避免在琐事上过度完美主义

“创意探索” 头

当你停止专注思考，进入放松、漫无目的的状态时，大脑的 “默认模式网络”会被激活。这个网络并非在休息，而是在后台进行信息整合、连接不同记忆、并孵化创意。许多 “Aha!moment” 都发生在此刻，因为它连接了意识思考未能触及的遥远节点

关于创意探索，也有一些具体的方法论

1）主动安排 “无聊” 时间：刻意在日程中留白，不安排任何活动，允许自己发呆、散步、望窗外

2）跨界刺激：阅读与你专业完全无关的书籍、杂志或纪录片。异质性的信息是创意的最佳催化剂

3）创意捕捉：在 “创意探索” 时间后，安排一个简短的（5-10 分钟）记录时间，将脑海中浮现的任何想法记录下来，无论它们当时看起来多么不靠谱

“恢复休息” 头

这里说的恢复休息，不是上了一周的班之后身心俱疲后，通过胡吃海喝，通宵打游戏追剧等来缓解表层焦虑的行为。高质量的休息不是一个纯被动的接收过程，而是一系列主动为大脑做的优化：系统性清理与重置（睡眠）、硬件升级与优化（运动）、软件调试与抗干扰训练（冥想正念）

1）睡眠：睡眠远非简单的休息。它将你的大脑从信息收集模式切换到关键的维护模式。在此期间，大脑会进行深度清理，清除白天积累的代谢废物（如 β- 淀粉样蛋白），巩固记忆，并将知识从海马体转移到皮层，形成长期记忆。将睡眠视为非协商性投资，如同对待 “深度工作” 头一样，在日历上锁定睡眠时间，保证睡眠的时长和质量；除了夜间睡眠，中午 20 分钟左右的短睡能有效清空工作记忆，为下午的深度工作块重启认知资源。关于睡眠的原理和重要性，可以参考这期播客《我们为什么要睡觉》：情商和心理治疗都靠睡觉？

2）运动：身体活动是最高效的健脑术。有氧运动能直接促进脑源性神经营养因子（BDNF）的释放，这种物质如同为大脑神经元 “施肥”，能促进神经细胞生长、增强连接，直接提升学习效率、记忆力和专注力的 “硬件基础”。定期运动就是在为你的整个认知系统进行硬件升级

3）冥想正念：如果说睡眠是清理缓存，运动是升级硬件，那么冥想就是对注意力这款 “核心软件” 的调试和优化。每天 10-15 分钟的正念冥想，其核心价值不在于增加注意力时长，而在于极大地提升你的“元认知” 能力 —— 即觉察到注意力涣散（Mind-Wandering）并将其温和而坚定地拉回的能力。这就像是每日为注意力进行的 “健身操”，长期练习能显著增强你对心智的控制力

正向传播与反向传播

如果我们把上面构建的注意力系统视为一个需要训练的神经网络。没有反馈的练习只是重复，无法带来精进。唯有通过 “反向传播” 计算误差并调整参数，模型才能变得更聪明。个人的注意力系统也需要持续的训练和迭代优化

正向传播比较直观，就是在每个规划好的时间块内，心无旁骛地执行单线程的 “正向传播”，即按照上面提到的Multi-Head策略，实现 “认知闭合”，屏蔽一切干扰，让思维在单一任务上深度推进

反向传播是最关键的一步。你需要一个反馈回路，可以粗略将其分为每日回顾与每周回顾

每日回顾

每天结束后可以花几分钟回顾一下当天的注意力分配情况，问自己一些关键性问题

1）一致性分析：“我计划的注意力投向与实际投向一致吗？” →如果不一致，是计划不切实际，还是执行时意志力溃散？

2）漏洞溯源：“今天最大的注意力‘漏洞’是什么？” →不要笼统地归咎于 “手机”。追问下去：是微信消息？是突如其来的邮件提醒？还是内心的焦虑感让你主动去寻找分心？

紧接着的问题就是 “明天如何堵上这个漏洞？”。这里的方法说实话会比较多样，需要针对性地制定微策略，同时也是因人而异。比如说如果是微信，能否将其放入定时开关的 “专注模式”？如果是邮件，能否关闭桌面通知？如果是内心焦虑，能否先花 5 分钟用纸笔梳理焦虑来源？

每周回顾

每周的回顾也是一个阶段性的回顾，比如说设定在工作日的最后一天如周五下午，可以从以下方面来梳理清楚过去一周的精力花费在了哪些方向上

1）审视 “注意力预算” 的分配：回顾过去一周的时间记录或日程表。你投入在不同 “注意力头”（深度、事务、创意、休息）上的时间比例是否健康？是否在低回报的浮浅工作上超支？

2）识别高价值活动：过去一周，哪些 “正向传播” 带来了最大的成就感和实际产出？下周如何复制并扩大这类活动？

3）优化日程模板：根据本周的洞察，为下一周设计一个更合理的 “串行多头” 日程模板。例如，发现下午 3 点后精力难以集中，就把 “深度工作头” 全部调整到上午

记录的工具比较多，市面上有比较多的 APP，对于 Mac笔记本的用户，笔者推荐的其实是自带的日程软件，跟《时间贫困》：一个人的时间花在哪里，是看得见的里提到的时间记账法比较类似

你是你所有注意力的总和

从《Attention Is All You Need》到 “Attention Is All YouHave”，这不仅仅是一次文字的戏仿，更是一个时代命题的转换。我们见证了机器如何凭借 “超级注意力” 崛起，也亲历了自身有限注意力在洪流中的飘摇。但本文的目的，并非制造如同纺织工人面对蒸汽机时、我们面对已经或即将取代大量工作岗位的AI时的那份焦虑和恐惧，是揭示一个更为根本的真相：你的注意力流向何处，你的生命就走向何处

Transformer模型通过精妙的架构，将有限的算力精准投注于最有价值的信息关联上。这恰恰是我们最需要向机器学习的智慧 —— 不是学习它的 “无限”，而是学习它的 “专注” 与 “效率”。我们无法扩展注意力的总量，但可以像优化一个精密模型那样，去设计它的分配

你定义的核心目标，是你向世界发出的Query；你精心筛选的信息环境，是你为自己构建的 Key-Value仓库；而你模块化管理的日程与精力，则是你独一无二的 Multi-Head策略。每日的反省与每周的复盘，就是你这个系统的反向传播算法，在误差中学习，在迭代中进化

我们守护和优化注意力，不是为了更高效地完成工作，而是为了更清醒地度过这一生。你的注意力，是你用来雕刻自我和塑造现实的唯一刻刀。你将它持续投向哪里，哪里就会在你生命中生长、壮大。你关注知识，便成为智者；你关注创造，便成为创造者；你关注所爱之人，便构筑了深厚的关系

在这个万物都在争夺你注意力的时代，能够清醒地决定自己要看什么、想什么、爱什么，或许就是我们这个时代最珍贵的自由与最大的力量。毕竟Attention is all you have, and finally all you are

本文的一些参考内容

《Attention Is All YouNeed》
《心理学原理》
《Navigation-relatedstructural change in the hippocampi of taxi drivers》
《娱乐至死》
《工作、体制化与自由》
《TheSocial Dilemma》
《深度工作》
‘You’vegot to find what you love,’ Jobs says
《我们为什么要睡觉》：情商和心理治疗都靠睡觉？
《时间贫困》：一个人的时间花在哪里，是看得见的
TheInvisible Gorilla
InattentionalBlindness
Limited CapacityTheory
Hebbiantheory
Attentioneconomy
Flow
AttentionResidue

Search Relevance: From Modeling to Ranking Mechanism

2025-07-20T23:51:23.000Z

Recently I’ve been researching search relevance, a problem withsearch-specific characteristics. Search relevance means content shown tousers must satisfy certain association with user-input query. Forexample, searching “KFC” shouldn’t show “McDonald’s” content.

Unlike feed scenarios where users have no content expectations, feedrecommendation algorithms can exploit based on user browsing history,recent hot content, etc., or explore new interests. But in searchscenarios, user-initiated queries have strong intent. Returned contentmust match this expectation, otherwise the search is invalid, causingsearch retention (LT) loss. From user perspective, if platform searchworks well, they should find desired content on first page, leading tomuch lower search browsing depth per PV than feed.

Scenario differences lead to different optimization objectives forsearch vs feed. For example, duration isn’t the most important metricfor search LT measurement. From ranking perspective, added relevanceconstraints mean limited candidates for ranking under specific query(compared to feed), while ranking formulas often add relevance factorsto achieve relevance objectives, interfering with maximizing originalobjectives (like revenue for ads).

Relevance constraints in ranking are why many effective feed rankingiterations are suboptimal or ineffective in search. For example, thephenomenon mentioned in Why are there few searchsystem tech articles but many recommendation system articles? - animportant reason is given query, insufficient relevance candidates limitranking search space, while ranking’s benefit should have increasingmarginal efficiency as candidate count increases.

This article discusses solution approaches for search relevance.Roughly, relevance involves two parts: relevance modeling, and themechanism for applying relevance model estimates. This articleattempts detailed discussion of these aspects.

Relevance Modeling

How to judge if query is relevant to content? Intuitively, this canbe divided into subjective and objective metrics:

Objective metrics: Statistics based on user behavior, likepost-search click rate (often called “click-through ratio”, higher isbetter), whether frequently changing query under same search intent(often called “query change rate”, lower is better), whether user searchbehavior is decreasing (search LT30)
Subjective metrics: Human evaluation metrics, generally relying onagreed standards defining different content’s relevance degree for aquery, then humans periodically sample to judge current search content’soverall relevance. But standards generally differ across apps andfrequently change even within one app.

Relevance modeling here refers to subjective metric modeling,which can also be understood as intermediate metrics for objectivemetrics, because insufficient relevance often leads to no clicks orfrequent query changes, even leaving platform.

Evolution Path

From technical perspective, judging query-doc relevance has gonethrough several stages. The article Dianping Search RelevanceTechnology Exploration and Practice - Meituan Tech Team mentionsrelevance modeling evolution:

Stage 1: Text Matching. Only consider query-docliteral matching degree, computing relevance through term-based matchingfeatures like TF-IDF and BM25. Efficient butpoor generalization, hard matching rules, can’t handle polysemy orsynonymy.

Stage 2: Traditional Semantic Matching Models. Notas crude as text matching, but mapping original query and doc to latentvector space, then computing similarity in that space. Most common ismapping both to embeddings, then computing vector distance or spatialsimilarity as score (dual-tower DNN models implicitly do this). Examplesinclude PartialLeast Square Regression methods, or mapping Doc to Query space formatching or computing probability of Doc translating to Query, see paperClickthrough-BasedTranslation Models for Web Search.

Stage 3: Deep Semantic Matching Models. Here deepneural networks DNN are introduced. Can be roughly divided into twoparadigms: Representation-based methods and Interaction-basedmethods.

Representation-based methods

Most common examples are dual-tower models like DSSM, also commonretrieval paradigm. Based on BERT encoders, mapping original textfeatures to vector space, then computing final relevance through cosinesimilarity or dot product. In Microsoft Bing’s NRM model, doc featuresbesides title and content also consider multi-source (Field) info likeexternal links, user click history queries. So Doc has multiple Fields,each Field has multiple Instances (text like Query terms). Model firstlearns Instance vectors, pooling all Instance representation vectors toget Field representation vector, pooling multiple Field vectors to getfinal Doc vector:

Representation-based method advantage: doc vectors can be offlinecomputed and cached. Online serving only needs computing Query vectorand simple similarity computation, good performance, low latency.Disadvantage: Query and Doc lack direct interaction during encoding,only relying on final vectors for similarity computation, might losefine-grained matching signals, limited expressiveness.

Interaction-based methods

This method doesn’t explicitly separate Query and Doc to learnsemantic representation vectors, but lets them interact at bottom inputstage. If dual-tower is retrieval paradigm, these models are rankingparadigm. ESIM was widelyused before pretraining models. First encode Query and Doc to initialvectors, then use Attention for interaction weighting and concatenatewith initial vectors, finally classify to get relevance score.

After introducing pretraining models like BERT, typically concatenateQuery and Doc as BERT sentence relation task input, then input model toget final relevance score, as in Multi-Stage Document Rankingwith BERT:

This method’s pros and cons are opposite to representation-based.Pros: High matching precision, capturing very fine-grained terminteraction and deep semantic info. Cons: Huge computational cost.Online serving requires real-time Query-Doc concatenation and forwardpass through large model, high latency, challenging performance.

Multi-Stage Training

Modeling needs solving basic problems including training sampleacquisition, feature construction, model metrics. In relevance modeling,direct domain labeling data is costly, so multi-stage training isconsidered to improve model effectiveness while controlling cost.

Training sample acquisition

Since relevance standards are platform-defined and frequently change,relevance training sample labels don’t have clear ground truth likeCTR/CVR tasks, but rely on human annotation. And if standards change,labels might change, so training sample acquisition cost is high forspecific domain relevance models.

Therefore, actual training often combines pretraining models + largeeasily-labeled relevant domain data for first stage, then humanannotated data for second stage finetune. Taking Dianping articleexample (other domains are similar), first use user click andnegative sampling data for Continual Domain-Adaptive Pre-training, thenhuman annotated data for second stage Fine-Tune.

First stage training: This stage treats user clickas “relevant” label, enabling low-cost large training sampleacquisition. But directly using click samples for relevancejudgment has significant noise, because user click is affectedby many factors (most common is position - earlier positions more likelyclicked, later not, but not due to relevance). So the approachintroduces various features and rules to improve training sampleaccuracy. Specific rules:

For positive samples, filter candidates through statistics ofclick, click position, max clicked merchant distance from user, takingsamples with impression CTR above threshold as positive. For negativesamples, only take docs before clicked doc with CTR below threshold,while random negative sampling adds easy negatives, but also usinghuman-designed rules for noise reduction: e.g., when Query categoryintent aligns with doc category system or highly matches doc name,exclude from negatives.

Second stage training: Second stage is commonfinetune training, fixing bottom layer parameters, using human-annotatedmore accurate labels to finetune top parameters. But different sampleshave different annotation value - easy pairs the model already judgeswell are less valuable than hard pairs the model can’t distinguish. Sofor annotation, Dianping doesn’t randomly send samples but produceshigh-value samples through hard example mining and contrastivesample augmentation for human annotation.

Hard example mining: Including 1) samples userclicked but old model judged irrelevant; 2) edge sampling for highlyuncertain samples like model prediction near threshold; 3) samples wheremodel or human identified difficulty, using current model to predicttraining set, samples where prediction disagrees with label, andconflicting labels, sent for re-annotation
Contrastive sample augmentation: Borrowingcontrastive learning ideas, generating contrastive samples for highlymatched samples and human annotating to ensure accuracy. Throughcontrastive sample differences, model can focus on truly useful infowhile improving synonym generalization. Example:

Here query “durian cake” is relevant to recommended “durian millecrepe, black forest cake”, but query “goose liver burger” is irrelevantto “iron plate goose liver, cheese beef burger”. To enhancemodel’s recognition of such highly matched but opposite resultcases, the method constructs contrastive samples “durian cake”vs “durian mille crepe”, “goose liver burger” vs “iron plate gooseliver”, removing info matching query text but unhelpful for modeljudgment, letting model learn key info determining relevance, whileimproving generalization for synonyms like “cake” and “mille crepe”.

Features

Since relevance is relatively objective standard (given query anddoc, posterior label is clear), not much affected by context info (likeposition, context). Or query and doc relevance won’t change due todifferent positions. Therefore, relevance model features are relativelysimple - query features generally original query text, doc featuresgenerally doc multimodal info (title, image) and meta info (doccategory, etc.).

With widespread LLM use, approaches using LLMs to constructadditional query and doc features have emerged. For query, basicapproach is constructing prompt based on query (e.g., based on queryand various platform search results), then having LLM summarize andoutput more accurate detailed query summary, then using this asadditional query feature input to relevance model.

Industry practice generally uses RAG (Retrieval-Augmented Generation)for this step. RAG combines retrieval and generation. Basic workflow:when model receives query, first retrieves relevant documents or infofragments in large index, retrieval based on similarity measure to findmost relevant info, then model uses retrieved documents as additionalcontext input for generation, usually by LLM. frames basic workflow:

RAG technology through more detailed LLM input can alleviate LLMhallucination, also commonly applied in specific vertical searchdomains. For more RAG details, see Large Model RAG(Retrieval-Augmented Generation) with Advanced Methods.

Ranking Mechanism

With relevance estimates, next is how to apply them online. Systemsgenerally ensure relevance through two means: relevance threshold andranking formula adding relevance term.

Relevance threshold: Fixed value, filtering low-relevance adcandidates
Ranking formula adding relevance term: Dynamically changing value,controlling post-delivery relevance target achievement

Search relevance’s fundamental goal is ensuring agreed badcase rateconstraint isn’t exceeded. If relevance score label is defined aswhether badcase, estimate’s physical meaning is probability of badcase,becoming a very common binary task. Then when model estimatesaccurately, controlling posterior estimate mean to equal some targetcontrols badcase rate around fixed value. E.g., if badcase target is5%, with accurate relevance estimates, keeping relevance estimate meanat 0.95 achieves this.

What should the ranking mechanism be? Below provides a solutionapproach.

Optimal Ranking Formula

First, optimal ranking formula derivation, formalizing the problem.Taking ad scenario maximizing eCPM as example:

Assuming $n$ requests, for request$i$’s shown ad, relevance estimate is$predict\_rel\_score_i$, ad value is$ecpm_i$, relevance mean target istarget. The optimization problem formalizes as (decision variable $x$ is ad selection strategy):

\[\begin{align}\max_x &\sum_{i=0}^{n-1} ecpm_i \\s.t. \frac{1}{n} &\sum_{i=0}^{n-1} predict\_rel\_score_i=target\end{align}\]

Problem Modeling

Since each request often has multiple ads, the above problem can befurther refined:

Assume request $i$ has $m_i$ candidate ads. For ad $k$ in request $i$, define:

$ecpm_{ik}$: Ad’s eCPM value
$s_{ik}$: Ad’s relevance estimatescore (i.e., $predict\_rel\_score$)
$x_{ik}$: Binary decisionvariable, $x_{ik}=1$ means selectingad $k$ in request $i$, otherwise $x_{ik}=0$

Then problem becomes:

\[\begin{align}\max &\sum_{i=0}^{n-1} \sum_{k} x_{ik} \cdot ecpm_i \\s.t. &\sum_{i=0}^{n-1} \sum_{k} x_{ik} \cdot s_{ik} =(\sum_{i=0}^{n-1} \sum_{k} x_{ik}) \cdot target \\& x_{ik} \in \{0,1\} \quad \forall i,k\end{align}\]

Problem Solving

1. Lagrangian Relaxation

Since constraint is equality and global, use Lagrangian multiplier toincorporate constraint into objective. Introduce Lagrangian multiplier$\lambda$, construct Lagrangianfunction $L$:

\[\begin{align}L(\mathbf{x}, \lambda)&= \sum_{i=0}^{n-1} \sum_{k} x_{ik} \cdot \text{ecpm}_{ik} + \lambda\left( \sum_{i=0}^{n-1} \sum_{k} x_{ik} \cdot s_{ik} - (\sum_{i=0}^{n-1}\sum_{k} x_{ik}) \cdot \text{target} \right) \\&= \sum_{i=0}^{n-1} \sum_{k} x_{ik} \cdot (\text{ecpm}_{ik} +\lambda \cdot (s_{ik} - \text{target}))\end{align}\]

Here $\lambda$ can be interpretedas “shadow price” of relevance constraint, meaning marginal impact ontotal eCPM per unit relevance score change. Maximizing $L$ is equivalent to maximizing:

\[\begin{align}\max L(\mathbf{x}, \lambda) \iff \max \sum_{i=0}^{n-1} \sum_{k} x_{ik}\cdot (\text{ecpm}_{ik} + \lambda \cdot (s_{ik} - \text{target}))\end{align}\]

2. Problem Decomposition

For each request $i$, maximizing$\sum_{k} x_{ik} \cdot (\text{ecpm}_{ik} +\lambda \cdot (s_{ik} - \text{target}))$ is equivalent toselecting ad $k$ maximizing $\text{ecpm}_{ik} + \lambda \cdot (s_{ik} -\text{target})$:

\[\begin{align}k_i^* = \arg\max_{k} (\text{ecpm}_{ik} + \lambda \cdot (s_{ik} -\text{target}))\end{align}\]

Therefore, optimal decision is for each request $i$, independently selecting ad $k$ to maximize the linear combination,which is each request’s ranking formula:

\[\begin{align}score_{ik}=\text{ecpm}_{ik} + \lambda \cdot (s_{ik} - \text{target})\end{align}\]

3. $\lambda$Solving

Mathematically, $\lambda$ isLagrangian multiplier obtained by solving constraint equation. In actualsystems, $\lambda$ can be adjustedthrough iterative methods (like binary search, gradient descent, oronline learning). Binary search can be used (because $s_i(\lambda)$ is monotonically increasingin $\lambda$):

Initialize $\lambda_{low}$ and$\lambda_{high}$
For each $\lambda$, compute allrequests’ selections (maximizing $\text{ecpm}_{ik} + \lambda \cdot s_{ik}$)and compute mean $s_i$
If mean $s_i > \text{target}$,decrease $\lambda$ (reduce relevanceweight); otherwise increase
Repeat until mean $s_i$ convergesto target

The above method requires obtaining all traffic and candidates,equivalent to replaying past period’s traffic to get historicaloptimal exchange ratio $\lambda$. But like optimalbidding, this is hard to directly apply because two prerequisites:(1) get all current day’s traffic data (2) changing actual winningads won’t affect bidding environment. These are often hard tosatisfy.

More common practice is collecting relevance estimate mean from pastperiod, then using PID for real-time control adjusting $\lambda$, pacing target being relevancemean equals target. This is similar to bidding control, also leading togap between actual and theoretical optimal exchange ratio, requiringvarious approaches to approach theoretical optimal.

Approaching TheoreticalOptimal

Analyzing further, actual PID control vs replay optimization differsin whether the control process perceives traffic value i.e.,eCPM.

Because optimization solving has maximizing eCPM objective inconstraint solving, searching for $\lambda$ just satisfying target. Butactual controller control only perceives current relevance meanachievement. When relevance isn’t achieved, $\lambda$ gets very large, making eCPMterm’s role in ranking very small, leading to non-optimal eCPM.

For example, in two consecutive time slices, first time relevance notachieved but has high eCPM candidates. Only considering relevance, $\lambda$ gets very large, preventing higheCPM candidates from showing (relevance term dominates). Next time slicerelevance improves (because first slice showed high relevance ads), butcandidates have no high eCPM. Now lower relevance weight, but shown ads’eCPM isn’t optimal either. But if reversed - first lower $\lambda$, second raise $\lambda$, can achieve balanced relevancewith maximized eCPM. This requires control perceiving traffic value.

Perceiving traffic value in $\lambda$ control, most intuitive is usingcollected traffic and ad candidates from past period $t$, then directly solving optimization viabinary search above for optimal exchange ratio $\lambda^*$, used for next time slice. Butthis has strong assumption that past period $t$’s traffic and candidate distribution issimilar to next time slice (or small difference) to beeffective.

Besides above method, another more intuitive approach is dynamicallyadjusting exchange ratio based on traffic value during control. Ifpartitioning traffic by value and relevance, we get four quadrants:

For these four traffic types, intuitively we can give prior exchangeprinciples:

High value high relevance: Lower exchange ratio, maximize high eCPMad delivery
Low value high relevance: Raise exchange ratio, maximize highrelevance ad delivery to fill high relevance
High value low relevance: Lower exchange ratio, but higher than (1),prevent relevance not achieved
Low value low relevance: Raise exchange ratio, higher than (2),minimize ad delivery

This contradicts theoretical optimal derivation conclusion “globaloptimal exchange ratio is fixed $\lambda$”. Because we’re giving differentexchange ratios for high vs low value traffic, not globally unified. Butactually theoretical optimal assumption (see all traffic) can’t besatisfied, and we’re approximating theoretical optimal, so don’t need tofollow fixed $\lambda$conclusion.

Additionally, this method’s effectiveness has two importantassumptions: 1) Relevance lost from high value traffic can berecovered from low value traffic; 2) Unit relevance has higher exchangeefficiency in high value than low value traffic. Point 1 isstraightforward - if can’t recover, relevance can’t be achieved. Point 2means eCPM and relevance score distributions differ between high and lowvalue, or intuitively: getting unit relevance in high value trafficcosts larger $\Delta eCPM$ than lowvalue traffic. This depends on actual inventory distribution (eCPMand relevance score distribution). From actual systems, this assumptionlikely holds.

Also, actual control needs to ensure overall target is achievableafter these exchange ratio adjustments. From this perspective,approach 2 better achieves this than approach 1, because can perturbbased on unified control coefficient. Approach 2’s solution is similarto “protect shallow optimize deep” perturbation strategy in bidding,perturbing $\lambda$ based on trafficvalue while ensuring overall target achievement. But unlike bidding doneat plan level, relevance is overall level, can’t be done at plan level.First, target is overall constraint, can’t decompose well to individualplans. Second, doing at plan level isn’t optimal because each plan needsits own target, adding more constraints and smaller solution space. Forsimilar approaches in bidding, see BidOptimization by Multivariable Control in Display Advertising.

Summary

This article discusses relevance modeling technology evolution andoptimal control strategies in ranking mechanisms, attempting to providesystematic solution approaches for this classic problem. Starting fromsearch vs recommendation scenario differences, search scenario’s strongintent characteristic determines relevance’s special nature: unlikerecommendation’s “purposeless browsing”, user search has clearexpectations, requiring results precisely match query intent. Fromtechnical perspective, this divides into relevance modeling and rankingmechanism.

In relevance modeling, basic evolution goes from text matching todeep semantic matching. Current mainstream methods divide intorepresentation-based and interaction-based paradigms, each trading offprecision vs performance. After introducing pretraining models and RAGtechnology, model understanding depth and generalization for semanticssignificantly improve. Two points deserve attention in relevancemodeling: First, LLM-based semantic understanding and generation: LLMsshow strong capability in semantic understanding, intent inference, andcontent generation. Future may deeply apply LLMs for deep query intentparsing, expansion, and normalization, even directly generating orenhancing relevant content summaries, further improving relevancejudgment accuracy and interpretability. Second, personalized relevanceunderstanding: Search intent has group commonality but also individualdifferences. Although current relevance isn’t context-dependent, futurerelevance models may better integrate personalized context (likehistory, real-time preferences), providing results more aligned withindividual needs while ensuring basic relevance.

In ranking mechanism, the optimization problem formalization derivesranking formula with relevance constraint $score =\text{ecpm} + \lambda \cdot\text{rel\_score}$. The Lagrangian multiplier $\lambda$ can be considered “shadow price”of relevance constraint, achieving balance between relevance target andeCPM maximization through $\lambda$control.

Current $\lambda$ control ismostly based on overall mean, hard to perceive traffic valuedifferences. Ideal state achieves fine-grained control by traffic valuetier - for high value high relevance traffic lower $\lambda$ to improve eCPM, for low valuehigh relevance traffic raise $\lambda$ to ensure relevant experience.Meanwhile need to consider not breaking overall target while achievingdynamic control.

Search ad relevance, ultimately, is the art and science of findingbest balance among user intent, advertiser needs, and platform value. Itrequires both deep technical modeling and algorithm optimization, anddeep insight into user search psychology and advertiser businessobjectives. Future search ad systems may be more intelligent andadaptive, dynamically sensing different scenarios and users’differentiated relevance expectations, precisely controllingbusiness-experience balance point.

搜索相关性：从建模到排序机制

2025-07-20T23:51:23.000Z

最近一段时间在研究搜索的相关性问题，一个颇有搜索特色的问题。搜索场景下的相关性，指的是展示给用户的内容，跟用户输入的query必须满足一定的关联关系，比如说搜 “肯德基”，就不应该出现 “麦当劳” 的内容

不同于在 feed 场景下，用户对内容基本无预期，feed场景的推荐算法可以基于用户历史浏览兴趣、最近热点内容等做exploit，或是通过探索用户的一些新兴趣做 explore。但在 search场景下，用户主动搜索输入的 query往往是有强意图的，出的内容也是要符合用户的这个预期的，否则这些搜索就是无效的，进而会造成搜索留存（LT）的损失。而在用户视角下，如果平台搜索的算法做得足够好，应该在第一页就能够找到自己想要的内容，而这这其实也导致了单pv 下 search 浏览深度会远比 feed 要低

场景上的差异，会导致 search 相较于 feed的优化目标也有不小差异。比如说搜索 LT的度量中，时长并不是最重要的指标；从排序角度，增加了相关性的约束，导致特定query 下可被用来排序的候选有限（相较于feed），同时排序公式中往往也要加入相关性因子来达成相关性目标，对最大化原目标（如广告就是收入）的效率造成干扰

排序的相关性约束，也是导致了很多在 feed 下有效的 ranking 迭代，在search 中效果不优甚至无效的原因，比如说这个问题里提到的现象为什么搜索系统技术文章很少，但推荐系统技术文章很多？，一个很重要的原因是给定query，相关性候选不足导致了 ranking 搜索空间不足，而 ranking本身的收益应该是随着候选量增加的边际效率是递增的

本文主要探讨下搜索场景下的相关性问题的解决思路。如果粗略地划分，相关性往往会涉及到两部分：相关性的建模，以及相关性模型预估分的作用机制，本文尝试对这部分的内容详细展开做一些讨论

排序机制

有了相关性预估分后，需要考虑的就是在线上如何应用这个预估分了。在系统中往往通过以下两个手段来保证相关性：相关性门槛和排序公式增加相关性项

相关性门槛：固定值，用于过滤低相关性广告候选
排序公式增加相关性项：动态变化值，控制投后相关性目标达标

搜索的相关性根本的目标是保证约定的 badcase 率约束不超，而相关性分的label 如果定义为是否 badcase，那预估分的物理含义即为是否 badcase的概率，就成了一个很常规的二分类任务了。则当模型预估准确的时候，通过控制投后的预估均值等于某个目标，即可控制badcase 率在固定值附近。如 badcase 目标是5%，相关性预估值准确情况下，让相关性预估均值保持为0.95，即可达成这个目标

那这个在系统中的排序机制应该是怎么样的，下面会针对这个问题提供一个解决思路

最优排序公式

首先是最优排序公式的推导，通过下面的推导把问题形式化，这里以广告场景最大化ecpm 为例

假设有 $n$ 条请求，第 $i$ 条请求曝光的广告的相关性预估分位 $predict\_rel\_score_i$，广告价值为 $ecpm_i$，相关性均值的目标为target。则需要求解的问题的可形式化表达为如下形式（其中决策变量 $x$ 为广告选择策略）

\[\begin{align}\max_x &\sum_{i=0}^{n-1} ecpm_i \\s.t. \frac{1}{n} &\sum_{i=0}^{n-1} predict\_rel\_score_i=target\end{align}\]

问题建模

由于每条请求往往会有多条广告，上述问题可进一步细化到如下形式

假设每个请求 $i$ 有 $m_i$ 个候选广告。对于广告 $k$ 在请求 $i$ 上，定义：

$ecpm_{ik}$：广告的 eCPM 值
$s_{ik}$：广告的相关性预估分数（即 $predict\_rel\_score$）
$x_{ik}$：引入二元决策变量，$x_{ik}=1$ 表示在请求 $i$ 上选择广告 $k$，否则 $x_{ik}=0$

则问题可表述成如下形式

问题求解

1. 拉格朗日松弛

由于约束是等式且全局，使用拉格朗日乘数法将约束融入目标函数。引入拉格朗日乘数$\lambda$，构造拉格朗日函数 $L$：

这里的 $\lambda$可以解释为相关性约束的 “影子价格”，表示每单位相关性分数变化对总 eCPM的边际影响，则最大化 $L$等价于最大化

\[\begin{align}\max L(\mathbf{x}, \lambda) \iff \max \sum_{i=0}^{n-1} \sum_{k} x_{ik}\cdot (\text{ecpm}_{ik} + \lambda \cdot (s_{ik} - \text{target}))\end{align}\]

2. 问题分解

对于每个请求 $i$，最大化 $\sum_{k} x_{ik} \cdot (\text{ecpm}_{ik} + \lambda\cdot (s_{ik} - \text{target}))$，等价于选择广告 $k$ 使得 $\text{ecpm}_{ik} + \lambda \cdot (s_{ik} -\text{target})$ 最大

\[\begin{align}k_i^* = \arg\max_{k} (\text{ecpm}_{ik} + \lambda \cdot (s_{ik} -\text{target}))\end{align}\]

因此，最优决策是对于每个请求 $i$，独立选择广告 $k$以最大化以下线性组合，同时也是每条请求的排序公式

\[\begin{align}score_{ik}=\text{ecpm}_{ik} + \lambda \cdot (s_{ik} - \text{target})\end{align}\]

3. $\lambda$ 求解

在数学上，$\lambda$ 是拉格朗日乘数，通过求解约束方程获得。实际系统中，$\lambda$可以通过迭代方法调整（如二分搜索、梯度下降或在线学习），如可以使用二分搜索方法（因为$s_i(\lambda)$ 是关于 $\lambda$ 是单调递增的函数），步骤如下

初始化 $\lambda_{low}$ 和 $\lambda_{high}$
对于每个 $\lambda$，计算所有请求的选择（最大化 $\text{ecpm}_{ik} + \lambda \cdot s_{ik}$)并计算平均 $s_i$
如果平均 $s_i >\text{target}$，则减小 $\lambda$（降低相关性权重）；反之增大 $\lambda$
重复直到平均 $s_i$ 收敛到target

上述方法需要我们获取的所有的流量和候选才能执行，相当于回放过去一段时间的流量得到的历史最优兑换比$\lambda$。但这跟最优出价比较类似，实际中比较难直接应用。因为这里有两个前提：（1）获取到当天所有流量的数据（2）改变实际竞胜的广告不会影响竞价环境。在实际中这俩往往是难以满足

更常见的实际做法是基于过去一段时间搜集的相关性预估值均值，然后基于pid 来做实时调控调整 $\lambda$的值，pacing 的目标就是相关性均值等于target。这部分其实跟出价调控比较类似，与计划最优出价类似，这也导致了实际的兑换比与理论最优兑换比有gap，需要通过各种手段逼近理论最优的兑换比

逼近理论最优

如果进一步分析，会发现实际通过 pid等控制器调控的方式，相较于流量回放直接解决最优化问题，差异在于调控过程中是否感知到了流量价值即ecpm

因为在解决最优化问题时，有最大化 ecpm这一目标在约束求解过程，会去寻找刚好满足 target 达成的 $\lambda$。但在实际的控制器调控中，只能感知到当前相关性均值是否达标了，当相关性不达标的时候会把$\lambda$ 调得非常大，导致 ecpm项在排序中发挥的作用非常小，这就导致了 ecpm 非最优

比如说在两个连续的时间片内，前一个时间相关性是不达标的状态，但有高ecpm 的候选，这个时候只考虑相关性，会把 $\lambda$ 调的很大，导致高 ecpm候选出不去（因为相关性项占了主导），而接着下一个时间片相关性有缓解了（因为前一个时间片出了高相关性广告），但候选没有高ecpm 的，此时降低相关性项的权重，但出的广告 ecpm也不是最优的了；但如果反过来，在前一个时间片降低 $\lambda$ 后一个时间片升高 $\lambda$，是可以做到打平相关性最大化 ecpm的，而这需要的就是调控感知流量价值

在调控 $\lambda$过程中感知到流量价值即 ecpm，最直观的就是用过去一段时间 $t$内搜集到的流量和广告候选，然后直接通过上面提到的二分法直接求解这个最优化问题，求得最优的兑换比$\lambda^*$，用作下一个时间片的兑换比。但这里有一个比较强的假设是过去过去一段时间$t$的流量和候选分布，跟下一个时间片的类似（或者说差异不大），才能有效，否则约束比较难达成

除了上面的方法，还有一种更直观的方法，就是在调控过程中直接基于流量价值动态调整兑换比。如果把流量按照价值和相关性两个维度划分，可以划分为如下四个象限

对于这四类流量，如果直观来看，可以先验给出如下的兑换原则

（1）高价值高相关性的流量，降低兑换比，尽可能多出高 ecpm 广告
（2）低价值高相关性的流量，提高兑换比，尽可能多出高相关性广告来填补高相关性
（3）高价值低相关性的流量，降低兑换比，但兑换比要比（1）更高，防止相关性不达标
（4）低价值低相关性的流量，提高兑换比，兑换比（2）要更高，尽量不出广告

这里的做法跟前面的理论最优推导出来的结论 “全局最优的兑换比是一个固定的$\lambda$” 有点矛盾。因为这里相当于是给高价值流量和低价值流量不同的兑换比，而不是全局统一的；但事实上理论最优的假设（看到所有流量）是没法满足的，而我们当前本身就是在做理论最优解的逼近，所以不一定要遵循理论最优的固定的$\lambda$ 的这个结论

另外这个方法有效也有两个重要假设:1）高价值流量损失的相关性可以从低价值流量上找补回来；2）单位相关性在高价值流量上的兑换效率比低价值流量的更高。1）比较好理解，因为如果找补不回来那相关性就无法达成，而2）指的是 ecpm和相关性分数的分布在高低价值是不一样的，或者更直观地说：在高价值流量上获取单位相关性损失的$\Delta ecpm$会比低价值流量更大，而这其实取决于实际的库存分布（即 ecpm和相关性分的分布），从实际系统来看，这个假设成立的概率还是不小的

另外，在实际调控中，需要考虑对这些兑换比调整后，大盘的 target是能达到的。从这个角度来看，其实方案 2 比方案 1是更能达成这一点的，因为可以基于统一的调控系数来做扰动。方案二的解决思路类似出价中的 “保浅优深” 的扰动策略，在保证大盘target 目标达成的前提下，基于流量价值对 $\lambda$做扰动；但是与出价不同的是，出价往往是在计划维度做这个事情，但相关性是大盘维度的，没法做在计划维度，一是target是大盘约束，没法很好拆解到各个计划上，二是做在计划维度上也不是最优的，因为做在计划上要求每个计划都有一个target，这样计划之间就不好做兑换了，或者说要约束更多了，求解空间更小了。关于出价问题上类似的解决思路，可以参考这篇文章《BidOptimization by Multivariable Control in Display Advertising》

小结

本文从搜索与推荐场景的差异出发，探讨了相关性建模的技术演进与排序机制中的最优控制策略，试图为这一经典问题提供系统性的解决思路。搜索场景的强意图特性决定了相关性问题的特殊性：与推荐场景的 “无目的性浏览” 不同，用户搜索带有明确预期，这要求结果必须精准匹配查询意图。从技术视角上可以分为相关性建模和排序机制两部分

在相关性建模中，基本的迭代经历了从文本匹配到深度语义匹配的演进。当前主流方法可分为基于表示（Representation-based）和基于交互（Interaction-based）两类范式，两者在精度与性能间各有权衡。而引入预训练模型及 RAG 技术后，模型对语义的理解深度和泛化能力得到了显著提升。关于相关性建模有两点值得关注，一是基于大模型的语义理解与生成：大语言模型（LLM）在语义理解、意图推理和内容生成方面展现出强大能力，未来有望深入应用 LLM 进行查询意图的深层解析、扩展与归一化，甚至直接生成或增强相关内容摘要，进一步提升相关性判断的准确性和可解释性；二是个性化相关性理解：搜索意图有群体共性，但亦存在个体差异；虽然当前的相关性与context不相关，但未来的相关性模型可能需要更好地融合用户个性化上下文（如历史行为、实时偏好），在保证基础相关性的前提下，提供更契合个体需求的精准结果

在排序机制中。通过最优化问题形式化推导了带相关性约束的排序公式 $score =\text{ecpm} + \lambda \cdot\text{rel_score}$。其中的拉格朗日乘数 $\lambda$可视为相关性约束的 “影子价格”，通过调控 $\lambda$可实现相关性目标的达成与 ecpm 最大化间的平衡

当前 $\lambda$调控多基于大盘均值，难以感知流量价值差异。理想状态应实现分流量价值层的精细化调控，对高价值高相关性流量降低$\lambda$以提升 ecpm，对低价值高相关性流量提高 $\lambda$以保证相关体验。同时需要考虑在不破坏大盘目标的前提下实现这种动态调控

搜索广告的相关性，归根结底是在用户意图、广告主诉求和平台价值三者间寻求最佳平衡的艺术与科学。它既需要深入的技术建模与算法优化，也离不开对用户搜索心理和广告主业务目标的深刻洞察。未来的搜索广告系统，或许将更加智能与自适应，能够动态感知不同场景、不同用户对相关性的差异化期望，并精准调控商业与体验的平衡点

工作、体制化与自由

2025-05-03T18:43:52.000Z

最近一段时间很忙，忙到整个大脑带宽被打满、回到出租屋只想躺平放空，或是忍不住无意义的刷短视频；忙到觉得自己工种变了（变成了一个消防员，天天在救火）；忙到甚至没有没时间去做更长期规划；能明显感觉到自己的词汇量、语义精度、表达能力和表达欲在迅速下降，同时自我对知识、对他人、对世界的好奇心和热情，似乎正在被浇灭。人身处其中的时候也许并不觉得有什么大碍，因为已经被 “体制化” 了，但一旦有更长的空闲时间，开始做 “上帝会发笑” 的行为，就能愈发感觉到了这种状态的恐怖之处，我觉得可能是时候给自己做个诊断了，于是有了这篇文章

本文主要是对最近一些经历和疑惑的碎碎念，以及试图求得其中的破解之法；涉及工作、情绪、短视频、以及自由的追求，文章极度发散，内容极度主观，就是一个情绪出口和以及写给自己的心理按摩，如果你愿意看，那祝开卷有益～

工作与情绪

如果说这一切的开端，也许是工作及其带来的情绪变化

世人慌慌张张，不过图碎银几两。偏偏这碎银几两，能解世间万种慌张

为了 “碎银几两”，我们不得不去工作，除了极少数的幸运儿能从工作中获得满足感与成就感，达到理想中的Ikigai状态。对于绝大部分的 “世人” 来说，工作带来的也不仅仅是 “慌张” 的情绪，反刍过去、灾难化未来、他人眼中期待的自我与内心真实声音的矛盾，这些行为会迅速让人陷入我们称之为 “内耗” 的状态：瞻前顾后，忧心忡忡地迈出每一步，还得时刻担心着自己明天会不会被裁了，进而迅速消耗掉一个人的生命力

该用何种心态面对工作、以及在工作中衍生出来的种种情绪，也许是每一个职场人的必修课，尤其是对于那批度过了懵懂的新手期、工作了几年开始建立了一些职场认知、对未来有一些期待但现状有不太符合预期、处于burntout 阶段的职场人

内耗：自我、他人、规训

内耗是最近几年在职场特别流行的一个词语；在心理学上，内耗并不是一个专业术语的，它描述的是一种心理状态，在这个状态当中内心充满的是挣扎和冲突的感觉

内耗的人一般会有的两种特质：反刍和灾难化思维。顾名思义，反刍就是把过去不好的体验、情绪和经历，反复在脑海里重演，回味那种尴尬的情绪和氛围，犹如吃苦耐劳的老牛一样，让那些本来应该消化掉的情绪一遍遍重复折磨自己；灾难化思维则是把一件事情的结果和未来都想象成最差的结果，在自己的脑子里当了一回灾难片的导演，自己来恐吓自己；这两种负面的情绪导致了一个人会把一件事情的结果或者过程过度强化，所以ta内心就很焦灼，那这个过程就发生了很多的挣扎和冲突，消耗了大量的心理能量，或者说生命力

在工作中导致内耗的直接的原因，《职场心累真相：90% 的疲惫和焦虑都来自这 3 种隐形内耗》中指出有 3个：（1）过度的自我批评（2）过度的关注他人的评价（3）限制性思维：即你 “应该” 这么做

前两者的关键词在与 “过度”，因为过犹不及，在其他语境下，这两点的描述的可能就是善于自省、共情能力强的这类偏 “褒义” 的特质了；第三点则是常说的社会时钟和社会规训，我们做的很多事情，也许并不是自己想做的，而是到了某个年龄，身边的亲人、朋友、媒体都在无一例外告诉自己应该去这么做的（比如说买房、结婚、生子）；在工作中，这几个原因的外显，就是当一个任务没能很好地完成时，会过度归因到自己身上，担心自己在其他人眼中会是一个 “没能力” 的员工，或者说日常的工作被一些自己不感兴趣但不得不去做的事情，工作的意义感荡然无存

另外，在生活中也许可以不在意其他人的眼光、不在乎社会给你打的标签；但是在工作中这并不容易，因为工作就是一个需要关注他人评价的过程，是一个被公司规训的过程：你需要关注合作方的评价、需要关注上级的评价、需要遵守公司的规章制度，做什么、不做什么都是有白纸黑字写着的，你需要交付好你的价值，以此来得到一个工作机会，以及可能的一个还不错的绩效。因此在工作中，第2 点和第 3点基本就是难以避免的，我们总得关注其他人的评价，总得去做公司让我们做的事情，当然，这里的 “度” 还是可以控制好的，但大部分的人是没法很好控制的，这其中也包括笔者

所以在工作中，更可操作的往往是第一点，即我怎么看待工作、看待我自己，或者说该用什么心态去应对工作及其衍生出来的一系列人和事，毕竟如同《男孩、鼹鼠、狐狸和马》里提到的 “我们只能看到外在，但一切发生在内在” 一样，如同《遇见未知的自己》中提到的 “外面没有别人，所有的外在事物都是你内心投射出来的结果” 一样，我们在内心塑造了世界，然后这个世界又塑造了我们，或者大白话说，同样一件事，心态会极大地影响我们的情绪和动作

工作只是交换，意义感和爱并非题中应有之义

对于完美主义者而言，在工作的很多时候是在演绎一个期待的自我，所以也会极度在意自己的行为，以及其他人的看法；虽然这种期待往往是不现实的

这种演绎会让一个人在工作进展不顺利时，会反复想是不是因为自己不够努力，而导致了结果不符合预期，而忽略了这个事情其实还跟上下游的合作方的配合有关、跟老板的方向判断有关、跟当前的市场环境有关；会让一个人反复猜测自己是不是领导心里那个最好的候选，如同小时候想的 “我是否父母心里最好的孩子”，进而会怀疑自己是不是做得够了，是不是要做得更多（这里面多多少少有一些讨好型人格在里面了）

为什么会这样？在上面的关于职场心累真相的那一期播客，以及《每个人都有至暗时刻，其实你并不孤单》中都提到了类似原因，心理学上有一个概念叫“价值条件化”：只有符合其他人的期望才能等到其他人的爱（有条件的爱），这种一般来自早年的经历，作为儿童的我们会有一种默许的规定：如果我能够被别人爱，能够被别人肯定，那是因为我按照权威对我的评价和指点去做了某些事，这个爱是有条件的，这些条件就是我只有按照他这么做我才有价值。这里又涉及到了老生常谈的 “原生家庭”、“东亚小孩” 的问题，社交媒体每每讨论到这一类话题，似乎都演变成了停滞在原地不动的、对原生家庭的批斗，《被讨厌的勇气》中把这种行为成为目的论而非原因论，即当前的不幸不是因为原生家庭导致的，而是因为先入为主相信了自己就是不幸的，不想改变而去找的原因；而我们需要谨记的一点是：人是有选择权的，是有能力选择自己的生活，不需要、也不应该用过去的经历来解释自己的一生

扯远了，工作很重要，但是意义感和爱并未题中应有之义，如果你是极少数能在工作中获得这两者的幸运儿，那么恭喜你；但对于绝大部分的人来说，工作就只是单纯的交换，用自己的时间精力、专业知识技能、指哪打哪的服从能力，去换取让自己维持生计的工资，仅此而已；在工业化程度越来越高的社会里，我们所做的事情会越来越螺丝化和单一化，这种标准化带来的结果是系统的鲁棒性和可持续性，因为螺丝坏了，替换一个就好，系统能够简单而快速地自我修复；而这也注定了工作对于个人的意义和价值在当今是一个奢侈品。打扮精致、穿行于灯火璀璨的高档写字楼的白领，跟流水线上、码头工地上重复着单一劳作的人，也许并无二样，即使是对于从事着看起来高大上的 “智力行业” 的程序员，不禁想到了大刘在《2018 年 4 月 1 日》那段让人拍案叫绝却、如同预言家一般的描述

程序员网络工程师、数据库管理员这类人构成了 IT 共和国的主体，这个阶层是 19 世纪的产业大军在 21 世纪的再现，只不过劳作的部分由肢体变成大脑，繁重程度却有增无减
在浩如烟海的程序代码和迷宫般的网络软硬件中，他们如两百多年前的码头搬运工般背起重负，如妓女般彻夜赶工
信息技术的发展一日千里，除了部分爬到管理层的幸运儿，其他人的知识和技能很快过时，新的 IT 专业毕业生如饥饿的白蚁般成群涌来，老的人（其实不老，大多三十出头）被挤到一边，被代替和抛弃，但新来者没有丝毫得意，这也是他们中大多数人不算遥远的前景…… 这个阶层被称作技术无产阶级

对于意义感，《每个人都有至暗时刻，其实你并不孤单》中提到，对于刚入职场的年轻人，因为对工作的新鲜感和热度还没褪去，也许还能通过给自己洗脑，赋予自己所做的事情以一些意义感，但是随着被职场毒打了几年，经历了更多的人和事后，对工作和职场看得更清楚、认知越来越清晰、再也没法给自己洗脑装睡后，会发现工作它不提供意义，它主要提供工资。但是播客也提到，一个人如果到了40岁再往后，或许可能会发现自己在做的事情会和这个世界某一部分的人群产生一些深层次的连接，ta能感受到一些召唤或者使命，即意义感这个东西可能是到了中年以后会慢慢浮现出来，或者至少对一部分幸运儿它会浮现出意义感，有种 “看山还是山，看水还是水” 的感觉

同样的，工作很重要，但不值得和爱挂钩；没必要把自己在原生家庭或者小时候某种没有被满足的需要投射到了职场当中；如果你太多的把工作等同于你的个人价值，等同于你有没有被爱、被尊重，等同于有没有成为 “父母眼中最喜欢的孩子”，会把个人的很多边界模糊掉（比如说生活和工作），而模糊带来的后果是很多动作会变形，心态也会变形

工作只是交换，为了交换我们不得不接受规训、做一些自己没那么喜欢但也没那么讨厌的事情，那在这个过程中，工作时候的 “我” 并不是真实的我，同样的，由于工作而导致别人喜欢或讨厌的 “你”，都不是真实的你。心理学上有两个词跟自我有关，一个是ego（客体的自我），另一个是self（主体的自我），前者更多指的是别人眼中的 “我”，包括 “我是不是一个被爱着的人”、“你是否能从我身上看到我有能力、我有价值” 这些都是跟ego有关的，它是一个跟自尊、自我评价，甚至有的时候是跟自负有关的一个自我；后者则是跟自我实现有关，“我要去创造什么”、“我要做什么样的事情”，都是跟self 有关的

职场中的 “自我实现” 的自我，往往指的是前者ego，而这其实是有点碍事的，因为工作就是去完成一个社会化的过程，去扮演一个 “拧螺丝” 的角色，但这个角色跟真实的自我self其实关系并不大，我只是去完成一个交换，在这个交换过程中，也许会让一些人喜欢，也会让一些人讨厌，但这并无大碍，因为这个角色并不是真实的自我

所以，不要在职场寻求爱，给予爱与被爱对大部分的人来说都很重要，你可以从你的朋友圈子、从你的爱人身上、从你的家庭中寻找和体会，但不要在工作当中去感受，因为不值得，套用李松蔚老师的话是这么说的：“对于一个有一定工作经验的人来讲，工作是很简单的。工作可能会涉及到计划、涉及到执行，有时候会涉及到创造，但是跟你的 ego，跟你的自我它没有那么大的关系，就是你在你的岗位上边做这个岗位应该去做的事情。这么说起来好像有点冷酷，但是在我心里边，其实我觉得有时候我们抱着冷一点的态度去面对一份工作的时候，有可能会让他做得更准确，然后你自己更轻松”

刀刃向内，给思想做一场手术

侃侃而谈这么多，最终还是要寻求一些破解之法的，否则就成了烂大街的那些没有勺子的鸡汤一般

如同前面所说，我们在内心塑造了世界，然后这个世界又塑造了我们，破解之法的关键，也许就是刀刃向内，为自己的思想做一场手术，改变自己的一些认知和想法，毕竟他人的评价和公司的规训，在职场中我们确实是不得不关注的

（1）觉察并接纳
能够察觉到自己的思维模式（反刍、灾难化思维等）和行为（过度自我批评、关注他人想法等）是导致了自己内耗的重要原因，有时候只是 “看见”，就能让自己的焦虑下降不少，因为再也不是如同无头苍蝇一般恐慌；其次是能够接纳真实的自己，接纳自己现状就是这么一个人，接纳事实是自己过去的经历塑造成自己就是这么一个人，但需要注意的是接纳并不是摆烂，人是有主观能动性的，是可以尝试去解决当下遇到的问题的

（2）课题分离
这里的 “课题” 指的是人能控制的事情，可能粗略分为个人课题和他人课题

个人课题（PersonalTopics）：指个人可以控制和改变的行为、想法和情绪。例如，一个人可以决定自己要学习什么、如何安排时间、如何应对压力等
他人课题（Other-PeopleTopics）：指他人的行为、想法和情绪，这些是个人无法直接控制的。例如，你不能控制别人对你的看法或者他们的行为方式

课题分离指的就是，别人怎么看带我是他们的课题，我无法干预；我们不必不干涉他人的课题，也不被他人的课题干涉（雅俗共享版就是 “关你屁事” 和 “关我屁事”）；因为我们需要意识到一点，自己不用让所有人的满意，一是因为无论你怎么做，都没办法做到让所有人都满意，二是他人其实也没那么在意你，很多你以为的 “别人眼中的你”，其实是你再给自己的大脑制造幻想，自己给自己加戏

（3）角色扮演
如同前面提到的 “工作只是交换，意义感和爱并非题中应有之义”，工作最重要的过程是交换，某种程度上我们只是在扮演一个社会化的角色，而在这个过程中，意义感和爱并不是必须之物，如果能找到那当然很好，找不到其实也是非常正常的

可以把自己想象成游戏中扮演的角色一样，上班就是游戏启动了，下班了退出登录回到现实世界中，游戏中的那个你，并不是真实的你；别人喜欢或讨厌的你，也不是真实的你；真实的你是回到现实生活的那个你

（4）保持 “初” 心
在《心理学博士怎么发疯？和李松蔚聊情绪：职场、东亚小孩、内耗、嫉妒和愤怒》中提到，职场中往往是新人的心态会比较好，因为刚工作，心里没太多负担，同时觉得未来是有盼头的；但新工作一段时间，晋升困难，努力的边际收益在初步递减，这个时候容易青黄不接，进而产生内耗等种种负面情绪，某种程度上，这是因为有了一年的工龄后，对自己的预期变得过高导致的

保持 “初” 心，或者说保持年轻的心态，意味着需要保护好自己的好奇心，时刻提醒自己 “我的认知是有限的、需要持续学习，工资少点没关系我也是在学习中的”；而不要过度关注自己的实际年龄（社会时钟规训的在外在表现）

（5）用好老板
需要意识到，老板是你的 “资源”，是协助你把事情做好的 “工具”；不要害怕去使用这个工具，或者麻烦到老板，因为老板的职责之一就是要协助你拿到目标的

虽然上面提到很多不要过度在意他人评价的原因和方法，但在职场老板的评价还是重要的，因为这决定了你的晋升和绩效等你希望交换得到的东西；但在这个过程不要去猜老板的预期，而是需要跟老板做好阶段性汇报，主动把一些进展披露给老板，老板也需要知道你的情况，同时应该根据你的情况给出建议和支持，老板真正害怕的是你一声不吭给他一个大的surprise

另外，不要压力过大，一个事情做不好，你老板也需要担责，老板有可能是误判了这个事情的预期，才把事情分配给你

（6）多样的参考系
不要让自己的生活只有工作这一个参考系，当你生活的支点越多，你的内核就越稳定，如同在《爬过第二座山》中提到的一样

当一个人评价自己的标准过于单一，比如只有工作业绩或者是财富数字；如果有一天这个唯一的参考系崩塌了，这对TA 来说，无疑是一种毁灭性的打击；这点也许对那些工作狂的一种诅咒

上面这 6个方法，篇幅很短，但是要真正做起来，其实很难，因为要在大脑中植入新的想法，要改变自己过去几十年养成的习以为常的习惯，需要我们长时间持续的刻意练习

短视频与 “体制化”

工作压力大、极度焦虑的时候，总忍不住刷短视频。犹如精神吗啡一般，短视频 “治愈” 着北上广深的钢筋丛林里被工作折磨了一天的打工人的身心灵，手指翻飞间，奇闻异事、家国天下，都缓缓流淌在那巴掌大的屏幕上，刺激着人的多巴胺分泌，让人流连忘返，忍不住往下刷，甚至于深夜不眠；然后第二天精神萎靡地回到工位，身心灵被工作暴揍一天后回到出租屋，继续刷着短视频疗伤，日复一日，仿佛一个无限的循环

这个现象在很多人身上都有，包括笔者，长期在这种 “好想逃却逃不掉” 的习惯下，也会让人不禁会问：到底是什么操控着我们做这个事情，这样到底会有什么影响，以及有什么方式能打破这种恶性循环（如果真的想打破的话）

“体制化”

在知乎的这个回答中，提到一个很有意思的现象 “早酒文化”

很多码头城市都有 “早酒文化”，也就是在早上喝几杯白酒，搭配高碳高脂的早餐，吃完以后再回家睡觉。形成这种文化的主要原因是，码头城市有很多以卸货为生的工人，而卸货通常是在晚上进行，在苦熬了一个通宵之后，已经身心俱疲，为了能睡个好觉，只好在早餐时喝点高度白酒，时间长了就形成了一种文化
这种生活是很伤身体的，这一点码头工人肯定也知道，但喝早酒的习惯却根深蒂固。原因也很简单：不这样做日子是要过不下去的。在充满苦的环境中，早上的几杯劣质白酒是唯一可以确定的甜，是生活唯一的 “正反馈” 来源。这也就是为什么有人劝他们戒酒，他们就会来一句 “这是我唯一的爱好，戒了活着还有什么劲”

仔细想想，其实我们和码头工人也没什么区别，大部分人的工作都是没有正反馈可言的，基本上就是枯燥任务的反复循环，犹如被惩罚的西西弗斯，一次又一次地推石头上山。人如果长期呆在这种负反馈的环境之中，生命力很快就会耗尽，不得不依靠 “低级娱乐” 来输入正反馈。这也就是为什么很多人下班以后，选择刷短视频，而不是学习的原因

为什么是短视频而不是长视频呢？因为在高压社会下，个人精力被工作的过度耗竭，让个人难以拿出足够的时间精力接受整块信息，被迫在碎片化的摸鱼休息时间中，做一些不动身体也不走脑的低功耗行为

但吊诡之处在于，当工作中的负反馈和业余时间 “低级娱乐” 带来的正反馈达到某种平衡以后，所有尝试打破这种平衡的行为，都会变得难以忍受。比如你打算告别短视频，尝试在业余时间学习新技能，容易导致工作中的负反馈无法消解。与此同时，进入陌生领域也会带来新的负反馈，两者叠加在一起，人就很难坚持下去（大多数人自我提升计划的失败，基本上都是这个原因）

长期如此，人就会被环境 “体制化”，也就是身体、大脑、认知，甚至是性格，都会往融入当前环境的方向发展，以适应让自己不那么痛苦；毕竟 “人是环境的反应器”，毕竟 “与恶人居，如入鲍鱼之肆，久而不闻其臭，亦与之化矣”

事实上，人的适应性是很强的，无论是对于上面的痛苦还是生活的愉悦；而这也许就是可乐只有在第一口是快乐的原因，体验过、适应了这种快感，就会觉得平平无奇，需要更强的刺激和体验才能够重新体验到新的快乐，我们追求的是 “加速度” 而不是速度本身。柯立芝效应也是在说这个事情，七年之痒，无非就是新鲜感全然殆尽，又没能发展出比新鲜感更深的维系双方关系的联结（我们往往管这叫亲情）

扯远了，人是适应性很强的动物，但在这种情况下的适应的代价就是灵气的消失，以及学习能力的退化，简称为 “体制化”。从某种角度来说，被 “体制化” 好像也没什么不好，最起码痛苦的感受没那么强烈了。但人所有的行为都是被情绪驱使的，所有的努力都是对当下的不满，如果痛苦的不再让你感到的痛苦，难受的不再让你难受，就会选择安于现状，人生的可能性也就消失殆尽了。就如同影史经典《肖申克的救赎》对 “体制化” 的阐述：

这些围墙很有趣，开始，你恨它，接着你适应了它们。时间久了，你开始离不开它们，那就是被体制化了（Institutionalized）

如果你不幸被 “体制化” 了，从里面爬出来可能要花费很大力气，因为这是一个很深的泥潭，靠自己的力量挣扎出来会很难。如何避免被体制化，回答里也给了一些建议

用低功耗维持工作运转。具体来说就是，把工作当成工具而不是目的，在心理上与工作脱节，不主动辞职，但也不追求进步，更不和同事争抢。把老板、上司、同事在内心 “NPC 化”，也就是不把他们当人看，无论他们多么傻 x，都不与他们发生冲突，但也不多干活
把节省出来的精力，专注于提升自己和扩展 “弱联系”，避免认知和人脉被 “体制化”
弱联系是什么意思？微弱的联系，比如说逢年过节群发的消息，可以理解为朋友圈的点赞之交，也就是互相知道对方是做什么的，但在生活中几乎没有什么来往。然而这种关系的作用，往往比生活中经常见面的 “强联系” 要大的多。可能在未来的某个瞬间，这种弱关系就能帮助到你
熟人社交是无效社交。人们通常只能从 “强联系” 中获得表达性支持，简单来说就是熟人只有情绪价值，你不开心了，能抚慰你，并和你一起吐槽让你不开心的人；而从 “弱连接” 中则更容易获得工具性支持，能产生更多实质性的价值

斯金纳箱的奖赏

在这一期关于抽卡的视频中，提到 “斯金纳箱实验（SkinnerBox Experiment）”，deepseek 给出的这个概念和实验过程如下

斯金纳箱实验，给我们呈现的事实是：小白鼠在一个有一定概率产生正反馈的系统中，会不断重复尝试某一个动作，以期望能够得到正反馈，即使这个过程中的也会出现负反馈（惩罚），小白鼠还是会乐此不疲得去重复这个动作，因为ta期待的是下一次未知的、有可能会出现正反馈的、持续分泌多巴胺让小鼠沉醉其中的奖赏

这跟巴浦洛夫的狗还不太一样，斯金纳箱里的小白鼠是自发学会了不断重复尝试某个动作；前者是经典条件反射（被动关联刺激与反应），后者主动行为与结果的联系

为什么现在但凡是个游戏都加入了抽卡机制？是因为游戏抽卡就是一个大型的斯金纳箱实验，在一次次游戏抽卡行为中，我们都在渴望着下一次的抽卡能够出现金光、能够抽到稀有角色、能够获得 “欧王” 的奖赏

斯金纳箱的原理，也被应用在了各种短视频 app中，小白鼠按压开关的行为变成了我们每一次的下拉刷新，以及在下拉刷新后期待得到的概率的奖赏：经过提纯的高浓度片段。没错，短视频是经过提纯的高浓度片段，将过去需要花大量时间去观看和思考的长视频碎片化成更纯粹的刺激、每次划屏就是换内容、算法还能记住你的偏好的提纯片段；每一次的下拉刷新，都是一次未知的奖赏或惩罚，如果是前者，会让我们在屏幕上疯狂点小红心，享受这个内容的同时开始期待下一次的奖赏，如果是后者，那也没关系，只需要轻轻一划，便能够重新拥有获取这种奖赏的期待，并且短视频推荐算法的考核机制，决定了你划到奖赏的概率会越来越高

所以，在深夜中一次次下滑屏幕刷短视频的我们，跟那只在斯金纳箱中重复按下按钮的那只小白鼠，也并无二样

那代价是什么

我很喜欢《钢之炼金术师 FA》这部动漫，以及里面提到的 “等价交换” 的概念：你如果想得到一些东西，必须要付出一些东西；因为 “命运所有馈赠的礼物，早已在暗中标好了价格”

不可否认的是，刷短视频的时候，人是快乐的，虽然这个快乐有点短期，也没法回味（仔细想想刷了几十个短视频的你，还记得这些短视频的内容么）；那么，这些快乐的代价是什么

表达能力

如果你花了大部分时间来观看短视频，你会发现，在日常生活中，不借助常用的网络用语，而是用自己的语言把一件事情描述的足够清晰，也会变成一件很困难的事情；你会发现过自己说话时如鲠在喉，想说但又说不出来，因为自己的词汇储备量，已经是很匮乏了

短视频平台的推荐算法考核目标，就是是内容快速传播、用户时长和完播率等，在这种模式下天然收到追捧的内容，是那些时间短、文本简洁、充斥着猎奇的观点的内容，同时导致短视频为了为了简洁，会使用大量的 “梗”，或者极度简化其中的事实与逻辑

这个回答就提到了，长时间的过度感知劣质样本集（在短视频的喜好推送中很容易重复出现）的结果有两个

（1）降低你的词汇量和语义精度，而这两点是思考、学习和认知的基础
（2）对感知的取样模式变得单一化 / 简单化，并且调整脑部的功能区用于对这种拟合的计算和思考，从而挤占了进行其他计算（比如中心路径的深入思考）的功能区

阅读长内容能力

仔细想想，短视频刷多了后，你还有耐心坐下来把一部电影完整看完吗？你在阅读长文本的时候，还有足够的耐性和时间去把文字完整读完吗？还是说在期待有一个短视频帮你把电影内容或者这本书的内容给总结了？

短视频通常以 15 秒到 1 分钟的短时长呈现，内容快速切换且充满视听刺激（如音乐、特效、高频率剪辑）。这种设计让大脑逐渐适应了 “快速反馈” 模式，触发大脑多巴胺的快速释放，形成 “观看 — 愉悦 — 更多观看” 的循环。这种即时满足机制降低了对延迟回报（如长视频的剧情铺垫或长文本的逻辑推导）的耐受性。长期来看，大脑对低刺激、需深度思考的内容失去兴趣，转而追求更易获得快感的短平快信息，导致注意力难以长时间集中于单一任务

沉迷这种快速反馈模式后，容易失去阅读长文字处理的功能，或者失去看内容深刻的长视频的功能。这时候再去进行阅读或者一些深度学习行为就会由于功能区被转移，而导致剧烈的不适感

系统性思考与推理能力

短视频的内容多为孤立片段，缺乏系统性，用户被动接受信息而无需主动整合逻辑。这种碎片化输入模式导致思维连贯性下降

另外，短视频篇幅过短，基本上只支持作者抛出观点和结论，但没有时间来论述这个结论或观点的推理过程，即只有 “是什么”，没有 “为什么”，而这又是验证观点是否合理的很重要的一环，同时也是能够延伸出很多其他话题的的重要过程，是锻炼思考能力的很重要的一个过程，如下图就是一个比较具体的过程

而当我们长期在这种只追求一个简短精炼的结论的阅读中，造成的后果是我们不再关注观点是否有支撑，大部分人只关注观点是不是合自己的胃口，同时对于各类社会现象，更多以感性的情绪输出为主

长期以往，你的知识体系会变得支离破碎，缺乏辩证思考能力，对于各类社会现象，更多以感性的情绪输出为主，久而久之，人就失去了识别真知的能力

空虚感

你是否会有过这种感觉，连续刷了几个小时的短视频后，会让人感觉特别空虚；与这种空虚相对反的，是用几个小时来专注做一件事情的充实感

这个回答就提到了这个原因，即人觉得充实与否取决于人的意识是否和时间的流逝所匹配

几个小时的短视频，起码得有几十个，但由于短视频本身是毫无规律可言的，所以短期记忆里没有留下什么值得大脑分析的东西；留不下东西，自然没有可分析的结论；相当于花了好几个小时，但是大脑只有大致印象，所以你的意识认为和时间流逝不匹配

但如果在做同一件事，大脑就会不停地强化有关这件事的记忆，并且由于同一件事的普遍规律性较强，人会很快分析到一些结论，对于人的感受来说，就是记得做了什么，并且知道做了什么，也得到了一些经验，感觉就很充实

我知道应该，但真的做不到？

上面提到的短视频对人的危害的观点，其实早就在各种媒体上被广泛传播过，但效果就有点像烟盒上印着” 吸烟有害健康” 一样，被烟瘾者习惯性的忽视了。为什么我知道应该，但就是做不到?

除了上面提到的 “体制化” 现象中，需要通过这类有短期 “正反馈” 的行为应对无聊的工作带来的生命力的耗损外；在《问题不大》的这期播客，就从心理学上分析了，报复性熬夜、持续刷短视频这种 “我知道应该，但真的做不到” 的现象的原因；播客内容很不错，推荐一听，这里就只摘录一些核心内容

在心理学的图式治疗中，认为人的体内有三类角色：内在的小朋友，内在的父母，应对者

小朋友跟弗洛伊德的本我有点像，小朋友也有很多类型，比如说脆弱的，焦虑的，愤怒的（这其实也是人很多情绪的映射）；而最常见的是脆弱的小朋友，与脆弱的小朋友同时出现的往往还有一个惩罚性的，或者叫高标准的父母

脆弱的小朋友代表个体内心未被满足的情感需求，通常与童年创伤（如被忽视、虐待、情感剥夺）相关。有点像一个受伤的、需要被保护的孩子，承载着恐惧、孤独、羞耻等原始情绪；脆弱的小朋友会在我们的内心发出这样的声音：“没有人会真正爱我”、“我永远不够好”、“我需要别人照顾我才能生存”

高标准的父母则是我们童年时期父母或重要他人的负面声音的具象化，这里面有分为两种类型：惩罚性父母（PunitiveParent）：象征严厉的批评和道德压迫；要求性父母（DemandingParent）：象征过高的标准和不现实的期望；我们心里很多自我攻击的声音，其实就是高标准的父母说的：“你活该被惩罚”、“你必须完美”、“你真没用”、“你不配被爱”

应对者则是为了逃避 “内在小孩” 的痛苦或满足 “内在父母” 的要求，发展出的防御策略；面对体内的矛盾，一般出现的应对者行为有三种：屈从（Surrender）、回避（Avoidance）、过度补偿（Overcompensation）

屈从型应对者：认同 “内在父母” 的批判，自我贬低（如：“我就是个失败者”）。行为上的表现被动接受虐待关系，不敢争取权益
回避型应对者：逃避触发痛苦的情境（如拒绝亲密关系、用娱乐、忙碌来麻痹自己）。行为上的表现就是情感麻木、社交隔离
过度补偿型应对者：用相反行为掩盖脆弱（如：通过控制他人对抗 “被抛弃” 的恐惧）。行为上的表现就是傲慢自大、过度竞争、讨好他人

为什么明知应该早睡，却熬夜刷手机？套用上面内在角色，可以在内心演化出这么一出戏

（1）内在父母激活：“你必须早睡！熬夜会变丑变笨！”（严苛要求）
（2）内在小孩反抗：“工作一整天已经很累了，我就想放松！”（需求未被看见）“早睡计划失败过那么多次，我肯定做不到……”（恐惧失败）
（3）应对者行动：用刷手机转移对焦虑的注意力（回避）

此时回避型的冷漠应对者为了屏蔽掉这些感受声音，会采取一种麻痹的方式，即机械地刷短视频，但此刻已经不是为了开心才这么做，单纯就是回避那种心里面很焦虑的感觉：不想再听小孩和父母吵了，然后就会用刷短视频的方式麻痹自己（有多少人中枪了）

“我知道应该，但真的做不到” 的本质，是内在父母用恐惧驱动改变，而内在小孩用抗拒保护自我，那我们能做些什么, 来缓解这种矛盾，播客里提到方法可以总结为：识别出三类声音，然后引入一个健康的成年人角色，来疗愈内在小孩、修正内在父母，并做出循序改变

第一步：识别三类角色的声音

写下冲突时的内心对话, 一般的模式是这样的

内在父母：“你应该……”
内在小孩：“可是我害怕/累/不想……”
应对者：“算了，先玩会儿手机吧。”

第二步：引入一个健康的成年人角色，修正内在父母，疗愈内在小孩

对内在父母，可以告诉他，你的做法是想个人过得更好，但也许你用这种非常苛责的口吻说话会适得其反。你可能会让脆弱的小朋友、焦虑的小朋友，他们都更不安，而他们的需求跟你的需求同样的重要，而当他们的需求没被满足时，可能个人也没能过得更好

对于内在的脆弱小孩，可以告诉 ta说你的这种需求是完全正当和合理的，你想要休息，你现在的日程表对任何人来说都是难以承受的，他就是会很累，就是你感到累，你想要休息这个需求我完全的认可、尊重和理解

但当我们表达对脆弱的小孩的理解和共情后，焦虑的小朋友可能在旁边就坐不住了，他可能会说 “你怎么能这样？你不会真的同意了吧？你不会真的让他休息一整天吧？那么考试就要通不过了？也学习不到新知识了”

那这个时候健康的成年人可以对焦虑的小孩这么说，我能够感觉到你现在很自责，虽然你已经做了这么多，但你好像觉得你还不够努力，你好像觉得你还可以做得更多。好像说休息一会就会让你觉得非常的自责，会让你觉得我怎么能这样，好像拉了很多的进度。我能理解你现在感觉到的这些着急、紧张，甚至是有点自责，但我想告诉你，他们不是真的。不管发生什么，不管你是不是去学习，不管你是休息了，你这个考试通过还是没有通过，你将来成为一个什么样的人。我想告诉你，我永远爱你，我会永远支持你。我是一个成年人了，我可以保护好你了。哪怕有一天周围的人对你都很生气，你爸爸对你很生气，他会指责你，但是没有关系，因为我是一个健康的成年人，我有能力保护你，你要相信我有能力保护你

第三步：设计 “微小行动” 替代应对策略

将 “应该” 拆解为可操作的步骤：比如说，原目标：“每天健身 1 小时” →新目标：“每天做 5 个深蹲”；允许渐进改变

自由

被无意义的工作束缚和折磨的打工人们，孜孜不倦地追求的一个目标，便是 “自由”：财富自由，时间自由，生活自由…

如果工作是罪魁祸首，引发了我们的种种情绪，消耗了我们的生命力，导致我们不得不通过 “低级趣味” 来获得正反馈，陷入这个死循环后，进而伴随着被 “体制化” 了

那是否不工作，就能够规避以上种种情绪及其衍生出来的问题；是否不工作，便能够自由？

不上班就好了？

说实话，作为一个前二十多年努力读书，毕业后就勤勤恳恳的在大厂上班，也不敢gap 的做题家，并没体会过不上班的感觉

但是在一些时间比较长的节假日，在疯玩了几天后，会有一种很强烈的空虚感，一种如同前面提到的刷短视频一般的空虚感；不上班所给予的巨大的自由，在此刻似乎化身成摄魂怪，吸走一切，只剩下空虚和无聊

在《欲望可以有界，意义必然无穷》，就讨论到了类似问题，大致就是每天睁眼起来不用上班很自由，但同时你要面临的是海量的选择，这些选择需要消耗的是你的大量的精力；并且人还是需要意义感，如果所做的事情没有太多意义感，你很快也会觉得无聊和枯竭，即使你一天什么也不做，或者在花了一天在玩游戏刷视频

后来看到了这个回答，感觉很好地解释了这个现象，关键点总结起来就是：要有产出 (作品)，不能只看不做

不上班，宅在家中，玩游戏、刷视频、想吃吃想睡睡，似乎是很多被上班折磨了很久的人的想象中的快乐；但吊诡之处在于，人类没有任何一种娱乐经得起长时间纯输入而不让人感到厌倦，比如说看小说、看动漫，只看完全不创作；或者玩游戏只玩，没有什么白金成就之类的游戏目标，没有写游评、写攻略的想法，纯玩，你很快就会腻（笔者对这一点可以说深有体会）

产出很重要，这里的产出，可以是你看完一部电影、一部动漫后，写的一小段的感悟和感受，可以是通关游戏后、录的视频发到B站（即使只有个位数的播放量），可以是去一段旅游后在小红书写下的一个体验或攻略。因为产出会不断强化你 “在做一件有意义的事” 的认知，同时产出也是一种即时反馈，它极大的帮助人保持积极的心理状态和乐观的预期；如果你隐居在你的小公寓里坚持写小说，可能到最后都没多少人看，但你一定会在写小说这件事上不断获得满足感。因为产出是一种价值锚定，是区别于 “爱好” 和 “随便玩玩” 的重要依据；产出某种程度上替代了工作给人带来价值感的部分，如果你干的足够好，也可以替代工资这部分

但产出不一定要变现，也不一定要别人的认可，甚至可能是对你以外的其他人都没啥意义（笔者写的很多文章就是如此）；最近比较喜欢听的一个播客栏目《远行者与破冰匠》，猫草老师说的一句话令笔者印象深刻，那就是 “创作给人第二次的生命”，无论是写作、录播客、做视频，都是创作；甚至养育一个小孩，也是创作。而其中的关键点，还是要有产出，有一个你能看得见摸得着的、经过你的构思和规划、未来能够被你重新看到并想起当时创作的过程的产出

或许其实这也是短视频与长视频的很大区别之一，短视频提炼不出有效的观点，但是长视频对人有启发的点在于，看完后能够提炼出一些观点（产出）

在《心理学博士怎么发疯？和李松蔚聊情绪：职场、东亚小孩、内耗、嫉妒和愤怒》这一期播客里提到，快乐是紧张感的解除，需要有一个过程和转变，如同前面提到的可乐是第一口才是快乐的，一直不用上班，没有压力的生活，也许只有前几个月，甚至是前几周才是快乐的；因为人的适应性还是非常强的，因为快乐和自由的日子也跟 “与善人居，如入兰芷之室，久而不闻其香，则与之化矣” 一样

回到标题，不上班就好了吗？看起来并不是，也许可以不上班，但是在不上班的日子里，还是得找到自己的主线，来替换原来被工作驱使着去走的那条路径；而在新的主线上，你需要有产出的、需要有一个 “实现自我价值” 的机会

我们与自由的距离

在孟岩的这一期播客里《E33与自由的距离》，提到一个笔者非常喜欢的观点：附在身上的东西越少，就越自由

这些附着，也许是他人和社交媒体给自己的标签、也许是公司和社会给自己的角色、也许是当时咬咬牙买房而背上的贷款、也许是奄奄一息的病人插在身上的五颜六色的管子

我很喜欢苏格拉底的这个故事，他去了集市逛了一圈后发出的感叹是：“Howmany things there are in this world that I do notwant”。这是另一种形式的自由，是让尽量少的东西附着在自己身上的自由，毕竟，notwanting something is as good as having something

除了身体疾病产生的病痛，其他的痛苦的确都是我们内心给予自己的，所以在保持身体健康，不轻易负债的前提下，其实个人是可以很自由的；keepyour identitysmall，不要给自己加太多标签，不要往自己身上挂太多东西，没有什么是必须要做的

那为什么社会生产力在大力发展，但好像现代人越来越不自由了？在韩炳哲的《倦怠社会》里提到 “世界成了一座巨大的百货商店”

在现代世界，一切神性和节日已不存在。世界成了一座百货商店。所谓的共享型经济 (Sharing-Ökonomie) 把我们每个人变成了售货员，期待着顾客的到来。
我们用越来越劣质的快消品填满世界，世界在商品中窒息。这座百货商店和疯人院并无本质区别。看上去我们似乎拥有了一切，我们却失去了最根本之物，即世界。世界丧失了语言和声音。在交流的喧哗声中，宁静消失了。商品的堆积和大众化填满了一切空白。
商品占据了天空和地面。商品化的世界不再适于居住，它失去了和上帝、神圣、奥秘、无限、崇高的联结。我们亦失去了惊奇的能力，生活在一座透明的百货商店里，成为透明的顾客，时刻受到监视和操控。
逃离这座百货商店成为当务之急。我们应当把商店改造成一个庆典场所，在其中生命才能获得应有的意义。

当世界沦为百货商店时，商品逻辑已渗透到存在的每个毛孔。共享经济的” 分享” 表象下，实则是将人性转化为可交易的” 服务人格”—— 民宿房东必须时刻保持微笑待客，网约车司机需要五星好评来维系生存。这印证了福柯的” 自我规训” 理论：我们主动将自我包装成商品，在数字评分体系下进行永无止境的自我优化

百货商店的” 透明性” 实为全景敞视监狱的升级版 —— 大数据算法比边沁的圆形监狱更高效地完成规训:抖音的推荐算法精准操控注意力，外卖平台的送餐时间量化压榨配送员。当一切皆可数据化度量，荷尔德林” 诗意栖居” 的世界彻底沦陷，连星空都成为文旅地产的营销噱头

在这座全球化的百货商店里，我们既是囚徒又是看守；而这也许就是为什么社会生产力在大力发展，但我们却越来越不自由了

人群与羊群

那难道逃离这座钢筋城市，逃离被消费主义构筑起来的现代社会，逃到 “瓦尔登湖” 去过梭罗一样的生活才算真正自由么

年轻时听歌的时候只爱听曲，但是随着年龄渐长，开始逐渐关注那些藏在词里的故事，最近在听陈奕迅的《任我行》，也许能够某种程度上回答上面这个问题

如同前面提到的笔者很喜欢的一个概念 “等价交换”，那自由的代价是什么？这个代价可能是孤独、恐惧甚至是死亡

少年时天真地认为 “神仙鱼困于鱼缸不自由”，于是将其放归大海，却导致其死亡，才发现 “原来神仙鱼横渡大海会断魂”—— 过度的自由可能带来毁灭性后果；而 “冒险半夜上山” 却因无人分享自由而感到 “没趣”，亦是说明了孤独是自由的副产品

天真得只有你令神仙鱼归天要怪谁
以为留在原地不够遨游就让牠沙滩里戏水
那次得你冒险半夜上山争拗中队友不想撑下去
那时其实尝尽真正自由但又感到没趣

年少时也许渴望 “缤纷乐园任我行”，但成年后逐渐意识到 “没有同伴不行”；因为到了某个年纪，会发现自己没有了当年冒险的魄力和勇气，会发现自由的代价自己似乎承担不起，会发现曾经迷途过，那滋味并不好受，所以才会 “怕追不上满街赶路人”，然后开始 “忌讳空山无人”、开始 “怕遥望星尘”

从何时你也学会不要离群从何时发觉没有同伴不行
从何时惋惜蝴蝶困于那桃源飞多远有谁会对牠操心
曾迷途才怕追不上满街赶路人无人理睬如何求生
从何时开始忌讳空山无人从何时开始怕遥望星尘

而自由，其实是可以存在于日常生活的微小选择中，可以存在于 “抱住两厅双套天空海阔任你行” 中，也可以存在于 “马路戏院商店天空海阔任你行” 中，而非必须与世俗彻底割，与社会告别才能得到

歌词最后的结尾，“顽童大了别再追问” 既是对天真的告别，也暗含一种释然：真正的自由或许不是脱离群体的 “赤地独行”，而是在群体中保持内心的独立

顽童大了别再追问
可以任我走怎么到头来又随著大队走
人群是那么像羊群

做一只清醒的羊

当我们尝试剖开工作的茧房、爬出短视频的泥沼，试图寻找自由的蛛丝马迹，而推导出来的所有解法，似乎都指向 “内心” 这一话题；《任我行》里的那句 “人群是那么像羊群” 轻轻叩击真相 —— 或许真正的自由，恰在于清醒地成为羊群中的一只羊

那些在写字楼里疲于奔命的我们，在短视频中机械刷屏的我们，在深夜焦虑内耗的我们，何尝不是被生存驱赶的羊群？但正如林夕在歌词中埋藏的辩证 —— 少年时执意离群索居的 “顽童”，最终发现 “马路戏院商店天空海阔任你行” 才是更深刻的自由。这并非对现实的妥协，而是在群体性生存中，学会与自己的孤独和解

被规训的日常里，我们依然可以保留 “神仙鱼困于鱼缸” 般的天真：在会议纪要的夹缝写下诗行，在通勤地铁戴上耳机筑起精神堡垒，在OKR的间隙喂养流浪猫时触摸生命的柔软。这些微小选择，恰似歌词中 “赤地踏过雪花”，是羊群中独属于你的足迹

不必为 “随大队走” 感到羞耻。西西弗斯推石上山的宿命里，加缪也能看见抗争的尊严；我们日复一日的 “体制化” 生活中，同样能开出自由的花。当你学会在晨会汇报时藏进一句聂鲁达的诗，在周报 PPT 里偷偷画一只跃出表格的鲸鱼，在团建聚餐后独自走向深夜亮着灯的便利店 —— 那一刻，你既是羊群中的一员，也是自己精神王国的君主

人群如羊群，但总有些羊在低头吃草时，眼睛始终望向远方的雪山

本文的一些参考材料

《每个人都有至暗时刻，其实你并非孤独》
《职场心累真相：90% 的疲惫和焦虑都来自这 3 种隐形内耗》
《心理学博士怎么发疯？和李松蔚聊情绪：职场、东亚小孩、内耗、嫉妒和愤怒》
《2018 年 4 月 1 日》
人是怎么废掉的？
“抽卡？整这个没用”
每天大部分时间都用于刷剧短视频，人容易满足于这种 “奶头热”，长此以往是否会影响人的智商，反应能力呢？
连续几个小时时间用来刷短视频会让人感觉空虚，用来专注做一件事情会让人感觉充实。这种差别的感觉从何而来？
为什么都说碎片化信息无用，我却感觉刷手机也可以学到很多东西？
《我知道我应该，但我真的不想》
《远行者与破冰匠》
《与自由的距离》
《倦怠社会》
《欲望可以有界，意义必然无穷》
没有经济压力、不婚不育不工作、每天睡到自然醒、爱干啥干啥，这样的人会烂掉吗？
任我行为什么能唱哭陈奕迅？

一起这种艺术

2025-03-12T22:52:27.000Z

文章的源起，是在深入了解听过 n次但选择性忽略了歌词里所诉说的故事的《远在咫尺》后，对最后那句 “一起这种艺术，若果只是漫长忍让，应感激终身的伴侣”颇有感触，把储藏在脑子里的很多零散的观点拽出来了，只是这些观点现在也是凌乱不堪，所以尝试通过这篇文章来connect the dots

本文尝试对 “爱情” 这一命题展开一些探讨，涵盖 “心动” 的源起、人来人往的 “投射与认同” 游戏、已经是标品的相亲流程、以及 “一起” 的这种艺术，内容依旧是随心所欲的发散，祝开卷有益～

心动还是冲动

当我们谈论 “心动”，脑海中刻板浮现的出来的往往是月色下的凝望、指尖不经意的触碰，或是灵魂共振的刹那。然而，心理学却揭示了一个看似 “煞风景” 却无比真实的真相：许多被我们奉为圭臬的 “心动” 瞬间，其根源可能仅仅是一场美丽的误会：“吊桥效应”（SuspensionBridge Effect）

想象你正身处一座高悬峡谷、随风摇晃的吊桥之上。脚下是深渊，耳边是呼啸的风声，心脏在胸腔里狂跳，手心渗出冷汗，呼吸也变得急促。此刻，生理上强烈的唤醒感（Arousal）—— 心跳加速、肾上腺素飙升、神经高度紧张 —— 正席卷你的全身。如果此刻桥的另一端走来一位陌生人，你望向 TA 的眼神，很可能被自己解读为 “一见钟情” 的火花。吊桥效应的核心在于：你将因环境危险而产生的强烈生理反应（恐惧、紧张、兴奋），错误地归因于了对眼前人的 “爱慕” 之情

这并非臆测，而是根植于心理学的 “情绪双因素理论”（Two-Factor Theory ofEmotion）

情绪体验 = 生理唤醒 + 认知标签
当个体经历不明原因的生理唤醒，如心跳加速、手心出汗、呼吸急促等，会本能地扫描环境，寻找一个合理的解释来 “贴标签”。如果此时环境中恰好存在一个潜在的 “情绪对象”，比如一位有魅力的异性，大脑便可能 “顺手” 将这阵生理风暴标记为 “心动”、“爱慕” 或 “性吸引”

这解释了为什么很多人会在冒险、旅行、极限运动中更容易产生感情，也是很多 “恋爱教程” 中，提示在约会场景选择一些适度刺激的活动，如过山车、密室逃脱、夜游等，可能更容易激发彼此的好感背后的原理

攀登险峰后的精疲力竭与成就感、异国他乡的陌生与兴奋、长途跋涉的相互扶持… 这些环境往往都伴随着显著的生理唤醒。当两人共享这些高唤醒时刻时，彼此的存在便成了解释这份激动最 “合理” 的标签，情愫由此滋生；这也是为什么共同经历挑战（如完成艰难的徒步、参与惊险的漂流）的同伴更容易擦出火花。而看恐怖片、坐过山车、玩密室逃脱、夜探 “鬼屋” 或在氛围独特的酒吧小酌，正是在人为制造可控的生理唤醒环境，利用吊桥效应增加对方将这种 “刺激感” 与你本人关联起来的概率

吊桥效应告诉我们：人类即时的情感判断极易受到当下生理状态和环境的裹挟。在特定情境（刺激的冒险、浪漫的旅途、迷离的夜色）下产生的 “心动”，一旦脱离那个特定的 “场”，回归到日常的、平淡的语境中，那份被误读的激情可能如潮水般退去，露出底下真实的沙滩：可能是一片空白，也可能只是普通的友情或好感

进一步来看，吊桥效应所揭示的误读机制，不过是庞大 “爱情化学反应” 交响乐中的一个音符。从冷冰冰的科学视角看，爱情或许只是一场索然无趣却无比精妙的生物化学反应。现代神经科学告诉我们，爱情本质上是一场由多巴胺（愉悦与渴望）、苯乙胺（兴奋与眩晕）、去甲肾上腺素（心跳加速）、催产素（依恋与信任）、血清素（情绪调节）等多种神经递质和激素精密配合、此起彼伏演奏的交响曲。当外界刺激（如吊桥的惊险、伴侣的出现）以特定的方式触发了大脑中相应的奖赏回路和情感中枢，这套复杂的生化程序便被激活，我们称之为 “坠入爱河”

这不由得让人想起钱钟书在《围城》中借方鸿渐之口发出的冷峻调侃：“世间哪有恋爱？压根儿是生殖冲动。”彼时的方渐鸿正在读叔本华，而这句话的思想源头其实也可以追溯至叔本华原来的论断：“所有两情相悦的情愫，不管表现得多么缠绵悱恻，都根源于性欲本能。”吊桥效应在一定程度上为这种 “祛魅” 观点提供了现代心理学的注脚 —— 浪漫心动的火花，可能只是生理唤醒被错误地贴上了 “爱情” 的标签，而性吸引往往是这种误读最直接的出口

人来人往终无果，落花流水有温存

人来人往的 “投射游戏”

心动是容易的。哪怕没有吊桥效应，一个惊艳的回眸、一条 “今天第 xxx个心动女生” 的弹幕，甚至一丝朦胧的好感，都可能点燃火花。让两人靠近并不难，难的是此后的相知、相处与相守

情感初探期，双方往往会因为不熟悉带来的相当程度上的保留与节制，而小心翼翼地开放自己的私人领域，同时也好奇地探索对方。他们修饰着自己也美化着对方，同时因为相互接触与了解的程度不深，也可以较少地受到对方自身特质的干扰，迅速地把自己的早期理想的客体形象，投射到对方身上；而对方为维系这份甜蜜，也迅速戴上相应面具，扮演起恋人理想的角色

这是亲密关系最甜蜜的阶段，因为此时双方还没有很深的联结，还在憧憬自己构想的理想亲密关系中，还不被真正在一起之后各种鸡毛蒜皮的琐事所困扰。此刻的恋人就像是两个小孩子，围着一个神秘的果酱罐，一点一点地尝它，看看里面有多少甜。然而，爱情并不只是甜的，当那个果酱罐被一点点地打开之后，当罐盖彻底揭开，它的神秘感与新鲜感都将消失，那时呈现在眼前的或许只是一只平凡无奇的小罐头，留给你的或许只有一地的鸡毛以及脏兮兮的双手，并不同于最初的想象，甚至，会让你失望

随着交往的加深，双方被压抑的真实自我在呼唤得到释放，他们无法再去扮演一个理想的恋人，而更想去做一个真实的恋人。因为持续扮演理想角色，如同穿着不合脚的水晶鞋跳舞，心力交瘁。那场支撑甜蜜的 “投射 — 认同” 双人舞，注定无法长久

但这也是亲密关系的真谛。人们之所以想组建亲密关系，之所以想爱与被爱，就是想获得一种亲密感：亲密感意味着需要把自我最深处的部分向他人也向自己呈现，卸除掉层层的伪装与防护，建立起真我与真我之间的连接感。在这个过程中，双方的信任感、依恋感开始建立，沟通的深度和广度也有所发展，开始牵涉到较深的情感卷入。这是心与心之间相知的契机，但同时也是一场充满风险的赌博

每个人在 TA的成长多多少少都会经历一些伤痛，正因为这些伤痛的存在，所以人们发展出了保护层和种种防御机制，以守护脆弱的内核。在这场充满风险的赌博中，当恋人鼓起勇气跟对方坦露自己的经历、一层层地剥落掉自己充满防御机制的外壳时，也是在将自己的伤痛展示给对方看，这是痛苦的，必定会像剥洋葱皮一样，一边剥落一边掉泪

如果对方的反应是积极的、接纳的，那么恋人即便落泪痛苦，也会因为感受到情感上的陪伴与支持，而坚定地一层层剥落掉那些保护壳，直到露出完整的内核。倘若双方都能如此坦然地接纳对方，那么爱情就会发展到稳定交往阶段，琴瑟和鸣，风雨同舟

但很多时候，受限于自己的狭隘、缺陷，以及种种未处理完的情结，人们渴望亲密，又害怕亲密，宁愿相信坦露真实的自我只会招致他人的批判、拒绝和抛弃，也很难相信有人肯接纳自己内在的真实。于是，在关系发展到一定程度时，就会退缩、害怕、扮演角色，在操纵与受控之间游走，生出嫉妒与厌恶、逃离与背叛之心，将关系场演变成游乐场，上演出种种的闹剧与幻想

写到这里，不禁想起陈奕迅的《人来人往》，这首唱尽了这城市里来来往往的爱情真相的歌曲，多少所谓的爱情，不过是贪恋那初遇时眉梢眼底的几分新奇。当那层薄薄的新鲜感如霓虹灯影般悄然褪色，所谓情愫便骤然失了支撑，只留下片片碎裂的虚空

歌中所唱 “感激车站里，尚有月台能让我们满足到落泪”，我们在人生经历中会上一列又一列的车厢，但每次停留的月台都象征着相遇的可能性和一个暂时停靠的港湾。此刻的朦胧为 “投射” 提供了完美画布 —— 恋人们将内心 “理想客体” 的幻影，浓墨重彩地投射于对方；对方为抓住心动，也迅速认同角色，戴上面具共舞于幻影之中。月台灯光柔和，果酱罐光泽诱人，满足感充盈如幻梦，尚未沾染现实尘埃

但 “爱若难以放进手里，何不将这双手放进心里” 却也早已预言了这游戏的脆弱。紧握虚妄的手，终将触到现实的棱角。当果酱罐见底，投射光环消散，被修饰的棱角显露，“真实自我” 的呼唤无法再被压抑。持续扮演，心力交瘁。这 “投射 — 认同” 游戏的能量本质是耗竭的，无法为真实关系提供永续动力

“闭起双眼你最挂念谁，眼睛睁开身边竟是谁”，看似追问旧爱新欢的歌词，却精准刺穿了亲密关系初期那场盛大而脆弱的 “投射与认同” 游戏的核心 —— 我们闭眼挂念的，往往并非眼前真实之人，而是自身投射其上、精心雕琢的幻影；睁眼所见身边之人，与闭眼挂念的、由自我投射并经由对方扮演共同构筑的幻影，判若云泥。这巨大的落差，正是 “人来人往” 最直接的原因。许多人，在这幻灭的废墟前，选择了歌词中的结局：“拥不拥有也会记住谁，快不快乐留在身体里”，然后转身，再次投入人潮，寻找下一个可供投射的 “月台” 和愿意扮演新角色的 “演员”，重复那短暂而注定幻灭的投射游戏。这循环，正是人来人往最本质的写照：投射、扮演、幻灭、离场、再投射……

落花深处的 “温柔共振”

人来人往的欲望都市里，发生着无数始终停留在 “投射与认同” 的浅层游戏、从未真正启程前往那个需要勇气与坦诚才能抵达的 “真我相遇” 之地的故事。月台永远拥挤，果酱罐永远吸引着新的 “演员” 和 “导演”。许多人或许终其一生，都在不同的月台张望，在不同的罐子前浅尝辄止，或许 “记住” 了许多人，留下了许多 “快不快乐” 的瞬间碎片，却唯独缺席了那唯一值得风雨同舟的旅程 —— 两个真实灵魂的相遇与共生

然而，在这看似宿命般的 “人来人往” 循环与 “投射游戏” 的幻灭中，却也存在着歌曲末尾那 “最美丽长发未留在我手，我也开心饮过酒” 的洒脱。即使最终的结局看起来不是世俗意义上的美好，但至少也经历过，开心过，而不是像顾城的《避免》里那种习得性无助般的无力感

你不愿意种花
你说：
“我不愿看见它
一点点凋落”
是的
为了避免结束
你避免了一切开始

避免了一切的开始，也避免了一切的体验, 如同《人间失格》文字透出来的遗憾一般：“若能避开猛烈的狂喜，自然不会有悲痛来袭。我试着去绕开所有的悲痛，但同时也是失去了所有的欢喜”

陈奕迅的另一首歌《落花流水》，仿佛就是《人来人往》的续集一样，为我们提供了另一种温柔而深刻的视角：过程也许比较比结果更重要。纵然两人的经历就如同落花和流水一样：最后 “水点蒸发变做白云花瓣飘落下游生根”，纵然两人最终也只是 “淡淡交会过，各不留下印”，但是 “这趟旅行若算开心，亦是无负这一生”，但是双方也 “经历过最温柔共振”，也许这也就足够了

这 “最温柔的共振”，恰恰可能发生在 “投射游戏” 的幕布偶尔被掀开一角的瞬间 —— 当双方在扮演的间隙，或因疲惫卸下心防，或因某个不经意的触动，短暂地、意外地瞥见了对方那未被修饰、未被投射覆盖的、真实的脆弱或光芒。即使这真实如惊鸿一瞥，即使它无法支撑两人走向长久的共生，但它确确实实发生过。这份 “共振”，不再是基于幻影的投射与认同，而是两个真实存在的灵魂，在生命长河的某一段交汇处，产生了片刻的、深刻的、无需扮演的共鸣与理解

这种共振，或许是在一次深夜的倾谈中，当其中一人鼓起勇气袒露了某个深藏的伤痛，对方并非出于扮演 “理想恋人” 的责任感，而是发自本能地流露出心疼与理解，那一刻的静默与凝视，便是 “最温柔共振”；又或许是在共同面对一个突如其来的困境时，双方暂时抛开了精心维护的角色，以最本能的、甚至有些笨拙的方式相互扶持，那一刻的默契与依靠，便是 “最温柔共振”；又或许，仅仅是在某个平凡无奇的午后，两人都放下了 “应该怎样” 的期待，疲惫地、真实地 “存在” 在对方面前，没有修饰，没有投射，却意外地感到一种奇异的、平静的接纳感，那一刻的松弛与自在，亦是 “最温柔共振”

即使一段关系最终未能逃脱 “人来人往” 的循环，即使那初期的投射游戏终告幻灭，只要其中曾有过哪怕一瞬这样的 “最温柔共振”—— 那份剥落了伪装、超越了角色扮演、触及了彼此真实内核的深刻触碰。这段旅程便不再是徒劳或虚无的，它已然成为生命长河中一枚独特的印记，一次珍贵的体验。在层层投射与防御之下，真实自我的触碰与共鸣是可能的，哪怕它短暂如烟火。这份体验本身，或许也足以对抗 “人来人往” 的虚无感，它提醒着我们，爱情的珍贵，不仅在于最终是否 “拥有”，更在于那 “交会时互放的光亮” 中，是否曾照亮过彼此灵魂深处真实的角落

所以，在 “人来人往” 的月台上，在投射游戏不断上演又落幕的剧场里，或许我们不必执着于强行留住注定风化的 “前身”（投射的幻影），而是学着珍惜那如流水般清澈、如落花般偶然却美丽的 “交会”，珍视那曾发生过的、短暂却真实的 “最温柔共振”

相亲、婚姻与彩礼

虽然人来人往的投射与认同游戏略有遗憾，但是也经历过最温柔的共振。但有过一段或弥足珍贵、或意难平，甚至是狗血荒诞的体验，在没对人造成实质性不可逆伤害的时候，不也是一段难忘的体验么。而人生，不就是由这样的一段段体验构筑而成的么

现实是并非所有人都有机会或勇气踏上这场 “投射与认同” 的勇敢者游戏，哪怕它短暂且充满幻灭的风险。当青春的潮水退去，而适婚年龄的礁石显露，更庞大的人群被推搡着涌向另一个截然不同的场域：相亲市场。《欲望都市 1：爱情并非必须，但人类还是很好玩的》里，猫草老师就针对相亲这个问题给了一个 “暴论”：相亲是一场有标准化流程的简历互筛，浪漫爱并非题中应有之义

在相亲市场中，不再是朦胧月台与神秘果酱罐的浪漫想象，而是明码标价、寻求最大公约数的现实交易所：身高、学历、户口、收入，这些硬指标被置于聚光灯下，成为衡量 “匹配度” 的核心砝码。因为往往对于走到相亲这一步的恋人，最有诚意的做法，是把大家的都关注的最大公约数（身高，学历，户口，收入）拿出来相互对比和匹配，这是一种非常标准化的流程，而浪漫爱并非这种标准化流程中的应有之义，更像是锦上添花的、难以量化的附加项

在这里，“闭起双眼你最挂念谁” 的追问是显得那么的不合时宜，“眼睛睁开身边竟是谁” 的答案，往往直接指向一份经过精密计算的、条件适配的清单。校园恋情的非标性可能（哪怕基于投射），在此被高效、务实的 “标准化匹配” 所取代，校园关系里的双方是有可能因为爱情在一块的，但相亲不是

步入婚姻的门槛，则让这份现实感更为沉重，甚至处处透露出一种时代的 “拧巴”。从纯粹的经济理性看，对当代男女而言，婚姻的必要性正急剧下降，双方都有养活自己的能力，在经济上，其实不太需要婚姻来获得一张饭票的机会，甚至结婚在某种程度上会拉低双方生活水平：住房、育儿、责任捆绑，每一项都可能成为压垮骆驼的稻草。

然而，许多人依然觉得自己 “需要” 婚姻。这 “需要” 的源头复杂而矛盾：或许是社会时钟滴答作响的规训，将 “成家” 刻入人生里程碑的焦虑；或许是深夜归家时一盏灯的温暖想象，驱散原子化社会冰冷的孤独；更深层地，是存在于人本身无法消解的那种孤独感

是的，人是孤独的。人与外物、社会乃至世界本质的分离，制造出一种令人窒息的 “监禁感”，迫使个体拼命寻求与他人深度的、制度化的连接（如婚姻）。但讽刺的是，这种源于孤独的连接渴望，却常常将爱情的重心异化为 “体验被爱”（寻求安全港、避风港），而非更主动、更具风险也更滋养灵魂的 “体验爱”（付出、理解、共振）。于是，婚姻的期待与现实的落差，不断酿制出失望与矛盾

这种拧巴的破解之道，或许在于我们还是要清醒地意识到自己在玩一个什么样的游戏，需要付出什么样的代价。选择 “标准化匹配”（相亲）路径的人，需要想清楚婚姻这份契约 “暗中标好的价格”，这个价格，也许是周末再也没有自己时间的 “不自由”，也许是责任驱动下为自己背上各种压力，也许是无数次无可奈何的妥协、以及可能的利益捆绑或牺牲，我们都需要问清楚自己，是否真心愿意做这场 “等价” 交换？而对于内心仍有悸动、渴望更深刻连接的人，则需要穿透社会给予我们的噪声和规训，想清楚自己真正渴求的体验是什么，而非社会时钟或他人眼光所定义的 “需要”

而当恋人双方终于鼓足勇气步入这场名为 “婚姻” 的游戏时，横亘在前的往往是那张沉重的 “入门券”：彩礼。网络上的喧嚣与对立，常将其简化为 “态度” 的象征。然而，更残酷的现实是，真正需要 “天价” 彩礼的家庭，往往并非索要虚无的诚意，而是实实在在地需要这笔钱来改善困顿的生活（如为家中兄弟支付婚房首付、偿还债务等）。吊诡的是，能匹配这类需求的结婚对象，自身的经济能力往往难以负担这天价数字。世界的割裂在此赤裸呈现：一边是生存的刚性需求，一边是难以企及的门槛。网络空间激烈的性别对立与虚空对骂，正是这种深层次社会结构矛盾与经济断层在婚恋领域的扭曲映射与情绪宣泄

最终，当我们审视这个时代，“爱” 与 “婚姻”，无论是基于投射幻影的勇敢游戏，还是基于现实考量的理性匹配，亦或是跨越经济鸿沟的制度结合，对绝大多数疲于奔命的年轻人而言，都显露着 “奢侈” 这两个字。在保守、收缩、低欲望的社会氛围下，在充满不确定性的经济环境中，生存与发展的压力已倾轧了太多空间。追求精神契合的 “爱”，需要充沛的精力、无畏的勇气和一定的经济底气；而承担 “婚姻” 的责任与成本，更是需要坚实的物质基础与强大的心理韧性。当点亮生活地图（工作、学习、看世界）已耗费了大部分心力与资源，当 “救公主”（建立深度亲密关系、步入婚姻）的成本高昂到令人却步，许多人只能无奈地选择延迟、观望，甚至放弃

一起这种艺术

相爱是容易的，甚至步入婚姻的殿堂也不难，难的是在一起后面对生活的风刀霜剑严相逼。因为相爱或许源于刹那的激情与投射的幻梦，步入婚姻殿堂也可能基于现实的匹配或冲动的勇气，但难的，是在日复一日的柴米油盐、在生活给予的责任和压力之下，如何维系那份连接，如何让 “在一起” 不至于沦为一种麻木的忍受或遥远的观望

红玫瑰与白玫瑰

《远在咫尺》以一个婚后男人的内心独白，跟我们重新诉说了一遍红玫瑰与白玫瑰的故事

当婚姻的蜜月期过去，当双方的新鲜感消失，当最初的吃喝玩乐变成了鸡毛蒜皮的日常小事，当浪漫的想象撞上现实的礁石，“一起” 的考验才真正开始。而这也正应对着前面提到的果酱罐被挖空见底、“投射与认同游戏” 无法再继续持续下去的时刻

很短暂狂热留下得一杯冷水
认定是可歌可泣的一双一对
长时期吃喝玩乐新鲜感减退

无论是恋爱还是婚姻，红玫瑰与白玫瑰、蚊子血与朱砂痣、白月光与饭黏子，都是一个永恒的困境，因为人这种动物特别擅长美化自己所不曾选择的那条道路。用张爱玲在《红玫瑰与白玫瑰》那句脍炙人口的话是这么说的

也许每一个男子都有过这样的两个女人，至少两个。娶了红玫瑰，久而久之，红的变了墙上的一抹蚊子血，白的还是 “床前明月光”；娶了白玫瑰，白的便是衣服上沾的一粒饭黏子，红的却是心口上一颗朱砂痣

即使已与一人缔结婚约，心中仍可能为 “未得到” 或 “已失去” 的她预留空间，每个对婚姻失望的夜深人静的夜晚，也许都会在想 “贪恋她抛弃你，是否当初想法不对”，但也会转念想无论最后选择谁，可能都会有同样的问题。歌词道尽了人性的不知足与对 “未选择之路” 的永恒幻想，如果再来一次换成那条没走过的道路，如果跟那个曾经没能在一起的 “白月光” 或 “朱砂痣” 共同一起生活，是否还是 “同样会记挂她，身于咫尺心于千里”，这 “身于咫尺，心于千里” 的疏离感，是许多婚姻中无声的暗流：物理空间的 “在一起”，远不等于心灵的同在

还是最尾我选择谁，同样背上这焦虑
同谐白首会是谁，这决定一边狠心一边又后悔
假使你是情侣假使你共同一起生活里
同样会记挂她身于咫尺心于千里不可抑压像潮水
得不到多么好
当得到不知怎算好
奢侈的一声天荒地老
如何能抵挡当中诱惑谁更好

“最爱” 的人在哪里？人终其一生，情感需求复杂多变，“最爱” 可能并非唯一。在不断的 “闹情绪” 与 “依偎” 的循环中，在 “数伴侣像流水” 的迷惘里，个体对自身身份和情感归属的游离感暴露无遗。活了一生都不知道 “最爱” 是谁，或许才是许多人的真实写照

一起会闹情绪分开了为何依偎生命里
谁是我最爱的应该一个应该三个应该数到像流水
数数到尽头终此一生之旅尚有几多新伴侣

《远在咫尺》某种程度上，展示了 “投射游戏” 彻底落幕、新鲜感完全消散后，婚姻生活可能陷入的僵局、疏离与精神游离。它无情地撕开了 “从此幸福快乐” 的童话面纱，暴露出 “一起” 的复杂、艰难与人性固有的矛盾

那么，“一起” 是否注定走向这种无奈的疏离或永恒的遗憾？弗洛姆在《爱的艺术》中给出了否定的答案，并点明了症结与出路：我们错误地理解了 “爱”

爱是一门艺术

归根结底，相爱容易，而相守不易，也是因为我们错误地理解了 “爱”

弗洛姆认为，爱不仅是一种情感，更是一种能力，一门需要学习和实践的艺术。它远非始于生理唤醒或 “投射 - 认同” 游戏后就能自然维持的状态。激情如同种子，而相依相伴的 “一起”，则需要在生活的土壤中，运用 “爱的艺术” 去精心培育

这门艺术的核心要素是：

关心(Care)：主动关注对方的需求与福祉，付出行动。这超越了最初的好奇与探索，是持续的关注与投入
尊重(Respect)：正视并接纳对方的独特性与真实存在，包括对方的缺点、局限和与你不同的部分（尊重意味着 “不利用”，让对方按其本性成长，而非强求其符合你的投射）
责任(Responsibility)：不仅仅是生活上义务的负担，也是对方精神成长、情感需求的一种积极回应和承担，这要求成熟与担当
认识(Knowledge)：持续、深入地理解对方，认清楚另一半核心的渴望、恐惧、伤痛与潜力。这是尊重与关心的基础

“一起” 的真谛，在于两个独立个体之间进行一场 “相互的驯化”，这不是控制或占有，而是在保持各自完整性的前提下，寻求 “不完整的融合”，是在亲密与距离之间寻找那个微妙的、动态的平衡点。它需要极大的耐心、时间，以及在漫长岁月中共同经历风雨、共同创造意义的能力。这绝非 “漫长忍让” 的消极消耗，而是主动运用爱的艺术去创造、去维系、去深化连接的过程

做到这一切确实艰难。爱有其生命，从萌芽、生长到最终凋零，是自然规律。但弗洛姆的精髓在于：即便结局注定，“用心呵护爱情生命” 的过程本身，就是抵御虚无、创造永恒价值的方式，因为一切终将黯淡，你的名声、财富、地位、甚至生命，所有一切终将黯淡，但是唯有被爱的目光镀过金的日子依然在岁月的深谷里闪耀着永恒的光芒，这份光芒，是爱的艺术赠予用心者的礼物

因此，当《远在咫尺》唱出“应感激终身的伴侣” 时，其深意并非仅仅感激对方的 “忍让”，而是感激在看清了人性的局限、经历了生活的磨损、抵御了 “红白玫瑰” 的诱惑之后，对方依然选择与你共同实践这门 “一起” 的艺术，共同守护那份在岁月深谷中依然闪耀的、被爱的目光镀过金的时光;这份感激，指向的是对爱的艺术之艰难的认知，以及对共同跋涉的珍视

一起这种艺术，若果只是漫长忍让，应感激终身的伴侣

我们听了太说，也说过太多 “不相信爱情” 的话，但那往往不是对爱的否定，而是对自己是否有勇气、有耐心、有能力去学习和实践这门最艰难也最珍贵的 “一起” 的艺术（爱的艺术）的怀疑与退缩。而破解《远在咫尺》中困境的钥匙，或许就藏在弗洛姆的箴言里：爱，不是被动感受，而是主动创造的艺术

一加一的终极迷思

从 “心动” 瞬间的生理迷障，到《人来人往》的投射幻影，再到《落花流水》中那惊鸿一瞥的真实共振；从相亲市场的精密匹配与婚姻现实的沉重门槛，到彩礼映射的社会断层与时代拧巴；直至《远在咫尺》里那 “身于咫尺，心于千里” 的疏离图景，我们遍历了 “爱” 的迷思与困境。而破解这一切的答案，或许指向了那个标题本身，也是《远在咫尺》最后的顿悟：一起这种艺术

“一起” 这种艺术的核心，是 “主动创造” 而非 “被动感受”。它要求我们放下对 “完美伴侣” 的虚妄投射，放下对 “最爱” 的唯一执念，如同放下对一件完美艺术品的幻想，转而专注于眼前这块独一无二的 “璞石”，那个真实的、不完美的伴侣。共同雕琢、打磨，在亲密与距离的动态平衡中，在冲突与和解的交织里，创造出一种只属于彼此的、独特的 “不完整的融合”。这份融合可能布满修补的痕迹，却因其真实与共创，而拥有了抵御岁月侵蚀与人性弱点的力量

“应感激终身的伴侣”，其深意并非感激对方的 “忍让”，而是感激那个愿意与你并肩站在生活的画布前，共同拿起 “爱的艺术” 工具，笨拙却坚韧地学习、实践、创造的同行者。感激 TA 与你一起，在看清了幻影易散、人性易移之后，依然选择在 “流水深处” 捕捉并珍存那些真实的回响，并努力将其谱写成属于两人的、虽不完美却独一无二的生命乐章，一段在岁月的深谷中被爱的目光镀过金的时光

一起这种艺术，终究是两个人的作品。它的完成既需要个人的觉悟与能力，更需要命运赐予一个同频共振的伙伴。这样的人，或许比 “理想伴侣” 的幻影更稀有，比 “最大公约数” 的匹配更难寻。当流水渴望与落花共谱一曲，但水点注定蒸发、落花注定飘落下游，或当刻刀已备，却无人执手共雕 —— 这或许，才是爱情这门艺术背后，最深的遗憾与最辽阔的留白。如同在《一加一》中Eason 最后的独白

其实…… 有冇呢个人……
根本有冇呢啲嘢嘅呢？

本文一些参考材料

《为什么相爱容易，相守不易？》
《欲望都市 1：爱情并非必须，但人类还是很好玩的》
《我值得被爱吗？聊聊低自尊与亲密关系》
《日本系列 4：老龄化启示录 —— 收支、产业与生死美学观》
陈奕迅的人来人往到底讲了个什么故事
陈奕迅的落花流水讲了个什么故事
《爱的艺术》
《我（们）的孤老生活》
深度解析《远在咫尺》
大话西游之仙履奇缘

Large Language Model Technical Reports Overview

2025-02-23T20:00:37.000Z

This Spring Festival, DeepSeek pushed large language model discussionto new heights. Even in an 18-tier small town’s New Year atmosphere,unexpected technological ripples were hidden. My cousin shouts dialectat her phone “Write me a New Year greeting”, my nephew chats withDouba’s gentle, understanding “school beauty”, even the alley’s Springcouplet vendor learned to customize gold-patterned designs withgenerative AI - these digital ripples in daily life, like a silentenlightenment movement, wove “large language models” into this smalltown’s capillaries.

Two years ago AI was like a bronze giant statue, trembling withcomputational roar when ingesting data, only able to process stellardata in first-tier city data centers. Today’s large models have becomeflowing streams, infiltrating along 5G base stations into county autorepair shops’ QR scan systems, kneaded into Kuaishou streamers’ dialectscripts, even hibernating in elderly phones’ voice assistants coughingonce to remind medication. From “brute force aesthetics” hundred-billionparameter arms race, to MoE architecture deftly slicing computationalcake, from millions-of-dollars lab aristocracy, to DeepSeek-R1 tearingopen commoner admission with $6M training cost - this evolution isn’tjust technological leap, but metaphor for tech narrative shifting from“monologue from the altar” to “dialogue with humanity”: when largemodels learn cost-optimized ballet on GPU remains, technology’scapillaries finally touched daily life’s heartbeat.

The passage above was generated by DeepSeek without complex promptsor repeated debugging - DeepSeek just “effortlessly” generated poeticyet realistic text. What’s more terrifying is this isn’t evenDeepSeek-R1’s main selling point: low-cost yet o1-comparable reasoningcapability.

After using it for a while, compared to two years ago, large modelsindeed have much improved user experience, no longer rigid textpermutation machines. Besides well-known data + compute “brute force”techniques, what technological advances and innovations occurred? Thepodcast 89.Line-by-line Explanation of DeepSeek-R1, Kimi K1.5, OpenAI o1 TechnicalReports I recently listened to introduces three representative largemodel reports. This article is a written version after learning. Hopeyou find it worthwhile!

OpenAI-o1

The report was released September 12, 2024: Learningto reason with LLMs. It mainly details that o1 performs very well onvarious benchmarks (much better than GPT-4o).

Chain of Thought (CoT) should be one of the biggest improvements inreasoning models compared to two years ago. Simply, before generatinganswers, the model does extended internal thinking, improving answerquality through multi-step reasoning, error correction, and strategyadjustment. This mechanism is similar to human “System 2” slow thinking,significantly improving logical rigor.

The report states “This process dramatically improves the model’sability to reason”:

It learns to recognize and correct its mistakes. It learns to breakdown tricky steps into simpler ones. It learns to try a differentapproach when the current one isn’t working.

Chain of thought’s underlying technology is reinforcement learning.The report shows this capability continuously improves with increasedtraining compute and inference thinking time, showing “Inference ScalingLaw” similar to AlphaGo, also similar to LLM pretrain stage’s scalinglaw with increasing data:

The report does extensive performance benchmarks showing CoTadvantages. But o1’s thinking process isn’t externally visible, onlyshowing summaries. OpenAI considers this helpful for monitoring modelsafety (like preventing user manipulation).

As for specific implementation algorithm details, OpenAI’s reportdoesn’t reveal much (after all, it’s closedAI now…). Externalspeculation at the time was mostly based on Process Reward Model (PRM),providing fine-grained supervision for each reasoning step rather thanjust final result (ORM). PRM was mentioned in OpenAI’s earlier paper Let’s Verify Step by Step -simply ORM only provides feedback on final result, PRM provides feedbackper step. The report shows this significantly outperforms outcomesupervision when training models to solve MATH dataset problems.

But DeepSeek’s report below shows PRM faces implementation challengesin practice - an unsuccessful attempt.

OpenAI’s report is very short with little effective information(after all, it’s closedAI now…).

DeepSeek

DeepSeek-R1:Incentivizing Reasoning Capability in LLMs via ReinforcementLearning introduces DeepSeek-R1-Zero and DeepSeek-R1 models.

DeepSeek-R1-Zero directly applies large-scale RL training on basemodel without SFT (Supervised Fine-Tuning). This was considered commonsense in LLM, traceable to deep learning’s 2016 emergence:fine-tuning pre-trained model parameters on specific task labeleddata to optimize performance on that task.

This is the first public research report showing LLM reasoningcapability can achieve good results through pure RL. More importantly,it provides clearer solution approach for various teams working on o1’spuzzle. As the paper states: “it is the first open research to validatethat reasoning capabilities of LLMs can be incentivized purely throughRL, without the need for SFT. This breakthrough paves the way for futureadvancements in this area”.

Before discussing the RL algorithms in the report, let’s review thewidely-cited RLHF (Reinforcement Learning from Human Feedback) process,then understand DeepSeek’s related improvements.

RLHF

RLHF has 3 stages: SFT, RM, and RL, as shown below (image from Whatis RLHF?):

(1) Supervised Fine-Tuning (SFT) Stage

This is the SFT process mentioned above, adjusting pre-trained modelbased on annotated data to initially adapt to specific tasks (likedialogue, instruction following).

Specifically, fine-tune pre-trained model using high-qualityhuman-annotated data (like human-written Q&A examples). Trainingmethod similar to pretraining, using autoregressive next-tokenprediction objective (like cross-entropy loss).

(2) Reward Model (RM) Stage

This stage builds a scoring model simulating human preferences,quantifying generated content quality.

Specifically, have SFT model generate multiple answers to sameinstruction, with humans ranking or scoring preferences. This process isalso where improving model safety (avoiding harmful content) and valuealignment (matching ethical preferences) relies on human correction.

Then modify output and loss function (e.g., contrastive loss,pairwise ranking loss) on original base model, training a regressionmodel (RM) that takes instruction and answer, outputting scalar rewardvalue.

(3) Reinforcement Learning (RL) Stage

Final stage uses RM’s reward signal to optimize SFT model to generatehigher-reward responses, adjusting model parameters through RLalgorithms (like DPO, GRPO, PPO) to maximize expected reward.

Taking PPO (Proximal Policy Optimization) as example, RL stage mainprocess is Step 3 below:

Let me focus on original PPO algorithm. PPO is a policy-basedalgorithm. Let me briefly introduce RL’s two main technical paradigms:policy-based and value-based.

Value-based methods focus on learning a precise valuefunction to evaluate expected return from executing action a instate s. When executing action, choose action with highest value. Commonmethods like Q-learning or DQN. Q-learning’s Q-table or DQN’s Q-networkrecord or fit this value function. Former can be understood as intuitivescore table, latter fits this table through NN. These methods generallyonly apply to finite action count (discrete) scenarios.Q-table also often limits finite states due to storage limits.

Policy-based methods focus on learning a policyfunction, directly outputting selected action based onestimated action probability distribution. Policy-based methodssupport both discrete and continuous action spaces.

For discrete action spaces, easy to understand - softmaxnormalizes n actions to probability distribution summing to 1, thenselect highest probability (this is also DQN’s approach).
For continuous action spaces, model outputs probabilitydistribution parameters. Common approach assumes actions followGaussian distribution - model outputs mean $\mu$ and standard deviation $\sigma$ parameters, and agent randomlydraws a value from $N(\mu, \sigma^2)$as actual executed action. Model learning goal is adjusting$\mu$ (moving distribution centertoward good actions) and $\sigma$(adjusting exploration certainty). This scenario typically uses NLL(Negative Log-Likelihood) loss, essentially MLE thinking, but unlikecommon binary classification MLE without absolute ground truth, usingenvironment feedback’s specific reward to determine final gradientweight.

Policy-based methods often involve policy gradient concept, basicallysame as ML’s backpropagation gradient, can be understood as weightedgradient. For discrete space, it’s a multi-class task, just withadditional reward multiplier in traditional multi-class backpropagation.Physical meaning is increasing probability for high-reward actions,decreasing for low-reward.

Back to PPO algorithm - PPO uses Actor-Critic architecture. PPO has 4models: Actor Model, Critic Model, Reward Model, and ReferenceModel.

Reward Model and Reference Model are modules unique to RLHF in LLMscenario. Native PPO (for robots, games) doesn’t have these becausein traditional RL (like playing Mario), environment directly givesReward (coin +1). But for LLM generating text, environment (user)doesn’t immediately score. So we need to simulate environment - RewardModel does this, providing environmental reward for Actor model.Reference Model, as the name suggests, prevents model deviating too farfrom original parameters, comparing distribution difference with currentActor model output, penalizing excessive distribution change through KLdivergence.

Actor Model (Policy Model)

This model generates LLM output (like response in dialogue), maintraining target. Usually initialized from SFT model above, then updatesparameters through policy gradient, maximizing reward signal whileavoiding deviation from Reference Model.

Reference Model

Also initialized from SFT model, parameters are fixed and notupdated, equivalent to Actor’s initial version. Used forcomputing KL divergence constraint (distribution difference betweencurrent Actor and Reference outputs), preventing Actor fromover-deviating from original distribution during training, mitigatingreward hacking and catastrophic forgetting.

Reward hacking mainly means model deviating from reasonable policy(like fabricating false info) to increase reward score. Catastrophicforgetting means model losing general knowledge from pretraining whenoptimizing new tasks. Both are addressed through KL divergenceconstraining Actor-Reference output difference.

Reward Model

This model is trained in stage (2) above, providing real-time rewardsignal for generated response. Training through contrastive learning onhuman-annotated preference pairs. Like Reference Model,parameters are frozen during training process.

Critic Model

Reward Model predicts immediate benefit (current action’sbenefit), Critic Model predicts current state’s long-term benefit.Critic Model’s important role is smoothing gradients, because if onlyusing final Reward to update, gradient variance would be very large (asentence written well might just be luck).

Critic Model output mainly computes Advantage Function, guiding Actoroptimization direction. The “advantage function” mentioned computesdifferently for specific RL algorithms, but core idea ismeasuring specific action’s quality relative to policy’s averageperformance. In PPO, advantage function definition:

\[A(s,a)=Q(s,a)−V(s)\]

$V(s)$: State-Value Function,average expected return executing all actions under current policy instate s (in PPO, estimated by Critic Model for current moment’s futureexpected reward)
$Q(s, a)$: Action-Value Function,expected total return after executing action a in state s (includingfuture reward discounting). In PPO, sum of Reward Model’s immediatereward and Critic Model’s next moment future reward.

When $A(s,a)>0$, action aoutperforms average, vice versa.

For why this function has this form, Everyone Can UnderstandRL-PPO Theory gives intuitive example (highly recommend reading thisarticle):

Critic Model’s role is similar to Reward Model (in fact, later GRPOalgorithm removes Critic Model), but Critic Model parameters areupdated. Since predicting value, update method uses MSE-like loss tominimize actual-predicted return difference.

Therefore, one PPO training round:

Actor generates response based on current policy
Reference Model computes KL divergence (prevent drift), Reward Modelgives final raw score. Final Reward = RM score - KL penalty
Critic Model observes every state during generation, outputtingpredicted $V(s)$ values
Actor computes advantage function $A(s,a)$ through step 2’s “final Reward”and step 3’s $V(s)$ values, updatesActor parameters through PPO-Clip mechanism
Critic also adjusts own parameters based on error between actualreturn and predicted value

For Actor Loss and Critic Loss, see Illustrating Large ModelRLHF Series: Everyone Can Understand PPO Principles and CodeInterpretation with code examples.

DeepSeek-R1-Zero: Pure RLwith GRPO

Although Actor-Critic paradigm in PPO above seems reasonable,Critic training accuracy can’t be guaranteed, so when valuefunction isn’t accurate, using wrong value estimate is worse thanabandoning it directly.

Group Relative PolicyOptimization (GRPO) does exactly this. GRPO is an RL algorithmproposed in DeepSeek-v2. As mentioned earlier, Critic Model role issimilar to Reward Model, and in GRPO, Critic Model is removed. How doesGRPO work? Simply, through multiple sampling of same problem’s differentanswers, directly using in-group reward statistics (like mean, variance)to compute relative advantage. GRPO vs PPO:

We can see GRPO has no Value Model (i.e., Critic Model), replaced bygenerating $G$ outputs each time,computing reward for each:

After getting $G$ rewards, computeeach reward’s advantage function $A_i$ through Group Computation. Method isbased on group mean and variance:

Then policy model loss function:

Overall GRPO training algorithm:

Reward Modeling

Although removing Critic Model while keeping Reward Model,DeepSeek-R1’s Reward Model isn’t model-based estimation like PPO above,but rule-based reward modeling. Paper uses two rule-based rewards:accuracy reward and format reward. Rule-based approach is used becausemodel-estimated reward modeling in large-scale RL training easily causesreward hacking (actually all reward-from-estimation approaches have thisproblem), while making training more complex.

DeepSeek-R1:User-Friendly Model with Cold Start

Although GRPO training significantly improved reasoning capability,DeepSeek-R1-Zero still has defects in practical use. On one hand,R1-Zero’s generated reasoning content has poor readability, languagemixing occurs, making reasoning hard to understand. On other hand,directly doing RL on base model without early guidance causes unstableearly training and slow convergence.

DeepSeek-R1-Zero encounters challenges such as poor readability, andlanguagemixing. To address these issues and further enhance reasoningperformance, we introduce DeepSeek-R1, which incorporates a small amountof cold-start data and a multi-stage training pipeline.

To address these, DeepSeek-R1 makes 4 improvements:

(1)Specifically, we begin by collecting thousands of cold-start datato fine-tune the DeepSeek-V3-Base model
(2)Following this, we perform reasoning-oriented RL likeDeepSeek-R1-Zero
(3)Upon nearing convergence in the RL process, we create new SFT datathrough rejection sampling on the RL checkpoint, combined withsupervised data from DeepSeek-V3 in domains such as writing, factual QA,and self-cognition, and then retrain the DeepSeek-V3-Base model
(4)After fine-tuning with the new data, the checkpoint undergoes anadditional RL process, taking into account prompts from allscenarios.

(1) Cold Start

DeepSeek-R1 collects thousands of long CoT data to fine-tuneDeepSeek-V3-Base, then does RL training above. This data obtainedthrough various methods like few-shot prompting, guiding model togenerate answers with reflection and verification. Cold start dataimproves output readability, incorporates human prior knowledge,provides better training starting point. After fine-tuning, doingDeepSeek-R1-Zero-style training gives better overall results than pureRL.

(2) Language Consistency Reward

For DeepSeek-R1-Zero’s language mixing in reasoning, DeepSeek-R1 addslanguage consistency reward during RL training. This reward is computedbased on target language word ratio in CoT - higher ratio gets higherreward. Although slightly decreasing model performance, effectivelyalleviates language mixing, making reasoning more readable.

(3) Rejection Sampling and SFT

First two steps focus on reasoning. This step collects various datato improve model’s general capabilities like writing, role-playing.

Contains two data types: Reasoning data and Non-Reasoning data.Rejection sampling means generating multiple candidate outputs,filtering best samples by specific criteria to improve data quality.E.g., generate 10 possible reasoning paths, only keep most logical orclosest to correct answer.

For reasoning data, part comes from previously trained model’sreasoning trajectories, then rule-based rejection sampling (e.g.,whether answer matches preset format, whether final result correct).Another part introduces generative reward model, judging whether modelreasoning logic matches human-annotated ground truth by inputting modelprediction and ground truth into DeepSeek-V3, evaluating logicalconsistency and semantic matching. Total ~600k data filtered.

For non-reasoning data like writing, factual QA, reuse part ofDeepSeek-V3’s SFT dataset, ~200k samples.

Using ~800k total samples, fine-tune base model DeepSeek-V3-Base fortwo epochs, improving both basic reasoning and general taskcapabilities.

(4) All-Scenario RL

This step mainly aligns model with human preferences (likeharmlessness, helpfulness). Based on step (3) model, additional RLtraining. For harmlessness, need to identify and remove potentiallyharmful content by examining reasoning process and final result. Forhelpfulness, focus on final result’s effectiveness.

Distillation

The report also confirms a “common sense” about distillation:distilling DeepSeek model reasoning capability to other models givesbetter results than original model and publicly available distilledmodels:

Additionally, with same model parameters, distilled model performsbetter than using DeepSeek-R1-Zero training process directly, whileusing less compute:

distilling more powerful models into smaller ones yields excellentresults, whereas smaller models relying on the large-scale RL mentionedin this paper require enormous computational power and may not evenachieve the performance of distillation

Unsuccessful Attempts

This part mainly mentions two unsuccessful attempts: Process RewardModel (PRM) and Monte Carlo Tree Search (MCTS).

Process Reward Model (PRM): Mainly means process reward model hard toimplement in practice. Paper mentions several reasons: First, definingsteps is difficult (breaking reasoning into steps). Second, definingreward for each step is difficult (model scoring not considered, humanannotation impractical). Third, if PRM gets each step’s reward fromestimation, reward hacking is inevitable for same reason above: allreward-from-estimation approaches have this problem.

Monte Carlo Tree Search (MCTS): Key method in AlphaGo, not proveneffective for LLM training. Main reason is excessive search space anddifficulty training value model. Paper does:

MCTS involves breaking answers into smaller parts to allow the modelto explore the solution space systematically. To facilitate this, weprompt the model to generate multiple tags that correspond to specificreasoning steps necessary for the search. For training, we first usecollected prompts to find answers via MCTS guided by a pre-trained valuemodel. Subsequently, we use the resulting question-answer pairs to trainboth the actor model and the value model, iteratively refining theprocess.

MCTS requires multiple simulations and evaluations for eachgeneration step’s possible paths. In games, possible path count islimited, but in natural language generation, each token choice involvesthousands of possibilities, causing exponential search space growth.E.g., a 100-token sentence with 100 candidate words per token has $100^{100}$ total paths, far beyondfeasible computation. Pruning can be done, but paper mentions thiseasily causes poor learning (getting stuck in local optima).

Also MCTS needs training value model to evaluate intermediate steps,difficult to train mainly because reward signal hard to define (samereasons as PRM). So general experience is MCTS suits closed,clear-objective tasks (like problem solving, code generation), but haslimited effect in open-domain generation (like creative writing,multi-turn dialogue).

Kimi

Kimi’s report KIMIK1.5:SCALING REINFORCEMENT LEARNING WITH LLMS has similar methods toDeepSeek-R1, 可以说是殊途同归了.

Both reports show RL driving models to autonomously generate CoT,with emergent behaviors like self-verification, reflection. Bothsignificantly improve reasoning capability, especially in math,programming tasks.

Both use distillation to transfer large model capability to smallermodels. Kimi proposes Long2Short optimization (like model merging, DPOtraining), DeepSeek-R1 directly uses large model generated data tofine-tune small models.

But Kimi’s training flow differs from DeepSeek-R1. Kimi still usesmulti-stage training (pretraining → SFT → long-chain SFT → RL), unlikeDeepSeek’s pure RL exploration. Kimi’s report also mentions manytraining details not in DeepSeek and OpenAI, providing useful info forother teams to reproduce.

The report mentions achieving good results through “Long contextscaling” + “Improved policy optimization” without complex techniqueslike unsuccessful MCTS and PRM exploration.

Long context scaling

“Long” means extending RL context window to 128k tokens, supportinglonger CoT generation, improving complex reasoning capability.

Report mentions RL prompt set - carefully selected problems (math,programming, logic reasoning, etc.) guiding model to generate long-chainreasoning during RL, also important training data source. This dataneeds constraints:

Diversity coverage: Covering STEM, programming, general reasoning,ensuring model adapts to different tasks
Evaluability: Answers verifiable through rules (like math formulaverification) or test cases (like programming), excluding easily guessedproblems (like multiple choice)
Balanced difficulty: Including simple, medium, hard problems forprogressive learning

Construction methods:

Auto filtering: Determine difficulty through modelself-evaluation (e.g., SFT model generating multiple answers, computingpass rate). Filter easily reward-hacked problems, like excluding simpleformat or random-guess solvable.
Tag system: Classify problems with domain tags (math,programming) and difficulty tags (easy/medium/hard), ensuring balancedtraining data distribution.
Validation and exclusion: If model can guess answer withinmultiple attempts (e.g., 8 tries), exclude. Avoid subjective judgmentproblems (like proofs), maintaining evaluation objectivity.

Long-chain SFT training data is generated from RL prompt set problemsthrough human or automatic high-quality CoT annotation (e.g., throughrejection sampling or human refinement), similar to DeepSeek-R1 coldstart data.

Improved policy optimization

Policy Optimization

Report proposes variant based on Online Policy MirrorDescent, similar to GRPO, also removing Critic model. Where$r$ is reward model, $\pi$ is actor model (also called policymodel) and reference model:

Formula (3) above shows final function similar to GRPO, using current$k$ sampled responses’ mean reward asloss weight, with KL divergence constraint between Actor and Referenceoutputs.

Length Penalty

Kimi 1.5 introduces length penalty, not mentioned in OpenAI orDeepSeek. Simply, as answer length increases, marginal ROI graduallydecreases (model effectiveness / training cost). So training introduceslength reward to constrain answer length, computing max and min lengthamong $k$ sampled responses, thengiving extra reward to shorter answers:

Sampling Strategies

Besides RL’s own sampling, paper proposes two additional strategies:Curriculum Sampling and Prioritized Sampling.

Curriculum Sampling means training simple tasks first, then hardtasks (based on RL prompt set difficulty). Reason is RL model performspoorly initially, so allocating equal training resources to hard tasksgives poor results and low efficiency.

Prioritized Sampling increases sampling probability for hard tasks.If a problem’s success rate is $s_i$,sampling probability is $1 −s_i$.

Long2short

This part is similar to distillation, transferring large modelcapability to smaller models. “Long” and “short” refer to long-CoTmodels and short-CoT models.

Report uses 4 methods: model merging, shortest rejection sampling,DPO, and long2short RL.

Model merging: Average two models’ parameters
Shortest rejection sampling: Sample n times (n=8) for same problem,select shortest answer for SFT
DPO: Sample n times, select shortest correct answer as positive,long answers (1.5x shortest) as negative (regardless ofcorrectness)
Long2short RL: Based on trained model, additional RL training withlength penalty above

Summary

When RL gradients surge through Transformer architecture, a silentrevolution in reasoning capability is reshaping large model evolutiontrajectory. From OpenAI-o1’s “System 2” slow thinking paradigm in chainof thought, to DeepSeek-R1’s breathtaking leap breaking SFT dependencywith pure RL; from PRM’s atomic supervision on reasoning steps, to GRPOalgorithm showing group relative advantage after eliminating valuefunction - these breakthroughs not only deconstruct hundred-billionparameter mystique from “brute force aesthetics” era, but compose newpossibilities in compute-algorithm duet. When DeepSeek uses rule-basedreward models to solve RL reward hacking dilemma, when modeldistillation compresses reasoning capability into lighter architectures,this technological evolution proves: large models’ core competitivenessmight not be how much stellar data they consume, but how to buildladders to production intelligence with more elegant algorithms on GPUremains.

The passage above was also generated by DeepSeek based on thisarticle’s content. After reading, I can’t help marveling at large modelcapabilities. Whether refusing or accepting, this LLM revolution isreshaping civilization’s texture with gentler roar than steam engine;when 18th century textile workers fearfully watched Jenny spinningmachine, they didn’t imagine mechanical arms would support entireindustrial civilization; now facing reasoning capability emerging inlanguage models, we’re more fortunate than ancestors - everyone cangather fire in open source community’s compute fragments, every countydeveloper can weave intelligent neural networks with API interfaces.Rather than worrying whether expanding model parameters will devourjobs, better to become first generation of LLM “algorithmic textileworkers”; history never sympathizes with passive ones, when LLM chain ofthought can penetrate mathematical proof’s copper walls, whenDeepSeek-R1’s reasoning capability is being distilled into elderly phonechips through model distillation - this silent cognitive revolution willforever leave hesitaters in steampunk metaphor.

Position \(t\)	Input	Predict target	Loss term
1	\(x_1\) (watch basketball Acomplete)	\(x_2\) (watch basketball Blike)	\(-\log p(x_2 \mid x_1)\)
2	\(x_1, x_2\)	\(x_3\) (watch food C skip)	\(-\log p(x_3 \mid x_1, x_2)\)
3	\(x_1, x_2, x_3\)	\(x_4\) (watch basketball Dcomplete)	\(-\log p(x_4 \mid x_1, x_2,x_3)\)

位置 \(t\)	输入	预测目标	Loss 项
1	\(x_1\)（看篮球 A 完播）	\(x_2\)（看篮球 B 点赞）	\(-\log p(x_2 \mid x_1)\)
2	\(x_1, x_2\)	\(x_3\)（看美食 C 跳过）	\(-\log p(x_3 \mid x_1, x_2)\)
3	\(x_1, x_2, x_3\)	\(x_4\)（看篮球 D 完播）	\(-\log p(x_4 \mid x_1, x_2,x_3)\)

Parameter	Common value	Note
Codebook size \(K\)	256 (or 512)	Too small = insufficient expressiveness; too large = prone tocollapse
Number of layers \(L\)	3-4	TIGER uses 4 layers
Effective vocabulary \(K^L\)	\(\sim 10^9\) order	Enough to cover ten-billion-scale item pools
Commitment weight \(\beta\)	0.25	VQ-VAE default
Codebook vector dimension	32-128	Determined by content encoder output dimension

参数	常见取值	说明
codebook 大小 \(K\)	256（或 512）	太小表达力不够、太大容易 collapse
层数 \(L\)	3-4	TIGER 用 4 层
有效词表 \(K^L\)	\(\sim 10^9\) 量级	足够覆盖百亿级 item 库
commitment 权重 \(\beta\)	0.25	VQ - VAE 默认
codebook 向量维度	32-128	由 content encoder 输出维度决定

方法	它在回答什么问题	反馈结构	是否建模” 动作影响未来”	优化目标
Supervised 端到端融合	从历史日志看，什么 \(w_k\)让最终列表指标最高？	(context, label) 静态对	否	离线 loss（最终指标的代理）
Contextual Bandit	这一次曝光，选什么 \(w_k\)使单步 reward 最高？怎么探索新组合？	(context, action, reward) 单步	否	单步即时 reward
Actor-Critic	这次动作会改变用户后续状态，怎么选 \(w_k\) 使长期累积 reward最高？	\((s, a, r, s')\) 序列	是	\(\sum_t \gamma^t r_t\)

层级	优化对象	主要方法	这一层的增量信息	不解决（边界）
第一层个性化精排	单 item 价值 \(s(u,i,x)\)	单目标 / 多目标加权精排（个性化隐式学进参数）	用户 - 内容匹配	业务间流量分配；列表内部相互作用
第二层个性化混排	业务级流量分配（受约束）	分数校准 → 动态调权 → Score Shading / Pacing	业务量纲对齐；平台约束；pacing 状态	业务内部哪条更该出；列表整体组合质量
第三层全局重排	整张列表组合质量 \(\pi^\star\)	item 级权重 → 约束重排 → 列表重排（含 Generator-Evaluator）→Slate	列表上下文；可行域；前序 - 后序依赖；长期反馈	上游候选质量本身

Method	What question it answers	Feedback structure	Models “action affects future”?	Optimization target
Supervised end-to-end fusion	From historical logs, which \(w_k\)produces the best final list metric?	(context, label) static pair	No	Offline loss (proxy of the final metric)
Contextual Bandit	For this impression, which \(w_k\)gives the highest single-step reward? And how toexplore new combinations?	(context, action, reward) single-step	No	Single-step immediate reward
Actor-Critic	This action affects user’s future state — which \(w_k\) maximizes long-termcumulative reward?	\((s, a, r, s')\) sequence	Yes	\(\sum_t \gamma^t r_t\)

Layer	Optimization object	Main methods	Incremental information this layer adds	What it doesn’t solve (boundary)
Layer 1 Personalized scoring	Per-item value \(s(u,i,x)\)	Single-objective / multi-objective weighted scoring (personalizationimplicitly learned into parameters)	User-content match	Inter-business traffic allocation; intra-list interactions
Layer 2 Personalized mixed ranking	Constrained business-level traffic allocation	Score calibration → dynamic weighting → Score Shading / Pacing	Cross-business commensurability; platform constraints; pacingstate	Which item to serve inside a business; overall list compositionquality
Layer 3 Global reranking	Overall list composition \(\pi^\star\)	Item-level weights → constrained reranking → listwise reranking(incl. Generator-Evaluator) → Slate	List context; feasible region; prefix-suffix dependence; long-termfeedback	Quality of the upstream candidate pool itself

Curve or metric	Definition	Main question it answers
Average uplift curve	\(U(p)\)	At this coverage level, what is the average uplift of the selectedpopulation?
Cumulative gain curve	\(G(p)=pU(p)\)	At this coverage level, how much cumulative increment has beengenerated?
AUUC	\(\int_0^1G(p)dp\)	Within the same evaluation population and treatment definition, howwell does the model rank users across coverage thresholds?
Qini	\(\int_0^1(G(p)-pATE)dp\)	How much more does the model ranking contribute than randomtargeting?

Function family	Form	Comment
Sigmoid	\(\sigma\!\big(\alpha(\text{ROI} -\lambda^\star)\big)\)	Most common; \(\alpha\) controlssteepness
Hardsigmoid / piecewise linear	\(\text{clip}(\alpha(\text{ROI} -\lambda^\star) + 0.5,\,0,\,1)\)	Cheaper to compute
Any monotone distribution CDF	\(F(\text{ROI})\)	More natural probabilistic interpretation (e.g. truncatednormal)
Softplus composition	\(1 -e^{-\text{softplus}(\alpha(\text{ROI}-\lambda^\star))}\)	More flexible for tail control

Dimension	CTR / CVR	Uplift
Learning target	\(P(Y \mid X)\), a singleconditional distribution	\(E[Y(1) - Y(0) \mid X]\), whichrequires two counterfactual distributions
Type of bias	Even with exposure bias, the model can still learn; it mainlyincreases variance	Once overlap is broken, the effect becomes directlyunidentifiable; this is bias, not variance
Signal strength	Labels are dense and signal is strong	Uplift is the difference of two numbers; the signal itself is 1–2orders of magnitude weaker
Error accumulation	One-directional accumulation in \(P(Y \midX)\)	Two-directional accumulation in \(\hat{\mu}_1 - \hat{\mu}_0\), and strategydrift accelerates it

Challenge	Multiple Treatments	Continuous Treatment
Causal identification	Need unconfoundedness for all \(t\); every \(t\) must satisfy overlap \(P(T=t\\|X) > 0\)	Same, but overlap becomes a density condition \(f_{T\\|X}(t\\|x) > 0\), which makesdensity estimation harder
Experiment design	Multi-arm RCT or stratified switchback; sample size grows roughlylinearly with \(K\)	Dose randomization (e.g. uniform dose sampling, or a fixed dose setwith random assignment); density coverage must be adequate
Model complexity	OVA is \(O(K)\), pairwise is \(O(K^2)\); joint modeling can mitigatethis	Need to learn a continuous function; GPS estimation itself isalready a nontrivial density-estimation problem
GPS-estimation stability	Discrete GPS only needs a multiclass model	Conditional density estimation (normalizing flow, kernel) isunstable in the tails; stabilized weights / clipping are oftenneeded
Decision solving	MCKP, NP-hard; approximated via LP relaxation + binary search on\(\lambda\)	Lagrangian first-order condition + grid search; cannot directly useROI ranking
Feedback loop	More severe than in the binary case—online strategies can cause some\((X, t)\) combinations to lack samplesfor a long time, so overlap keeps deteriorating	Same, and the bias in density estimation is further amplified byIPW

函数族	形式	备注
Sigmoid	\(\sigma\!\big(\alpha(\text{ROI} -\lambda^\star)\big)\)	最常见；\(\alpha\) 控制陡峭度
Hardsigmoid / 分段线性	\(\text{clip}(\alpha(\text{ROI} -\lambda^\star) + 0.5,\,0,\,1)\)	计算更便宜
任意单调分布 CDF	\(F(\text{ROI})\)	概率解释更自然（如截断正态）
Softplus 复合	\(1 -e^{-\text{softplus}(\alpha(\text{ROI}-\lambda^\star))}\)	长尾控制更灵活

维度	CTR / CVR	Uplift
学习目标	\(P(Y \mid X)\)，单一条件分布	\(E[Y(1) - Y(0) \midX]\)，需要两个反事实分布
偏差类型	即使有曝光偏差，模型仍能学；表现为方差变大	重叠性破坏后直接不可识别，是 bias 不是variance
信号强度	标签密集、信号强	uplift 是两个数相减，信号本身弱 1-2 个量级
误差累积	单向叠加在 \(P(Y \mid X)\) 上	双向叠加在 \(\hat{\mu}_1 -\hat{\mu}_0\) 上，且策略漂移会加速放大

挑战	多 Treatment	连续 Treatment
因果识别	需要 unconfoundedness 对所有 \(t\)成立；每个 \(t\) 都要满足重叠性 \(P(T=t\\|X) > 0\)	同上，且重叠性变成密度 \(f_{T\\|X}(t\\|x)> 0\)，对密度估计要求高
实验设计	多臂 RCT 或分层 switchback；样本量随 \(K\) 线性增长	剂量随机化（如均匀采样剂量、或固定剂量集合 +随机分配）；密度需要足够覆盖
模型复杂度	OVA 是 \(O(K)\)，pairwise 是 \(O(K^2)\)；联合建模可缓解	需要学连续函数；GPS 估计本身就是个非平凡的密度估计问题
GPS 估计稳定性	离散 GPS 用多分类模型即可	条件密度估计（normalizing flow、kernel）容易在尾部不稳，需要stabilized weights / clipping
决策求解	MCKP，NP-hard，靠 LP 松弛 + 二分 \(\lambda\) 近似	拉格朗日一阶条件 + 网格搜索；不能直接用 ROI 排序
反馈闭环	比二值更严重 —— 线上策略会让某些 \((X,t)\) 组合常年缺样本，重叠性持续退化	同上，且密度估计的偏差会被 IPW 放大

吴良超的学习笔记

Generative Recommendation (GR): What It Actually Replaces, and What It Doesn't

ThreeImplicit Assumptions of the Cascade Paradigm

Assumption A: Items areDiscrete Atoms

AssumptionB: Each Step Can Be Scored Independently

AssumptionC: Recommender Systems Do Not Exhibit a Significant Scaling Law

GR ReframesRecommendation as “Sequence Generation”

Three Key Questions

Item Tokenization:Semantic ID and RQ-VAE

RQ-VAE Principle

Representative Work: TIGER

Limitations

Three Routes ofGenerative Architecture

Route1: Training a Generative Foundation Model on Recommendation Data

Change1: Training Objective from “Per-Sample Scoring” to “Behavior SequenceTransduction”

Change 2:Pointwise SiLU Replaces Softmax Attention

Change3: Retaining Hash / Sparse System, Not Strongly Dependent on SemanticID

Route 2:End-to-End Generative (OneRec / TIGER Family)

Route 3: Directly ReusingGeneral LLMs

Differences Among the ThreeRoutes

Decoding& Inference: Letting Generated Tokens Land on Real Items

TrainingObjective: From next-token to Preference Alignment

Why next-token LossAlone Is Insufficient

OneRec’s IterativePreference Alignment

TheEssential Difference Between GR’s RL and LLM’s RLHF

GR’s Landing FormsAcross Cascade Layers

Recall

First-Layer Fine-Ranking

Third-Layer Re-Ranking /Slate

Second-LayerMixed Ranking: Hard Constraints and Online Control Are GR’s CurrentBlind Spot

Practical FeasibilityJudgment

Summary

生成式推荐 GR：它到底在替代什么，又没替代什么

Cascade 范式的三个隐含假设

假设 A：item 是离散原子

假设 B：每一步可以独立打分

假设C：推荐场景不存在显著的 scaling law

GR 将推荐重述成 “序列生成”

三大关键问题

ItemTokenization：semantic ID 与 RQ - VAE

RQ - VAE 原理

代表性工作：TIGER

局限性

生成式架构的三条路线

路线一：利用推荐数据训练一个生成式基础模型

改动一：训练目标从” 当前样本打分” 变成” 行为序列转导”

改动二：pointwiseSiLU 替代 softmax attention

改动三：保留hash / sparse 体系，不强依赖 semantic ID

路线二：端到端生成式（OneRec/ TIGER 系）

路线三：直接复用通用 LLM

三条路线的差异

解码与推理：让生成的token 落到真实 item

训练目标：从 next-token到偏好对齐

为什么单纯 next-token loss不够

OneRec 的 IterativePreference Alignment

GR 的 RL 和 LLM 的 RLHF有什么本质区别

GR 在 cascade 各层的落地形态

召回

第一层精排

第三层重排 / Slate

第二层混排：硬约束与在线控制是GR 当前盲区

实际落地可行性判断

总结

个性化排序公式：从个性化精排到个性化混排再到全局重排

第一层解决了什么

单 item 打分为何不够

单项可加

分数同量纲

没有额外全局约束

环境是静态的

第二层的职责：在多业务之间分流量

第二层的方法：不改变精排序的个性化混排

分数校准

动态调权

ScoreShading / Pacing：把混排看成受约束的动态出价问题

第三层的职责：把整张列表组合得更好

第三层的方法：允许直接改精排序的全局重排

item 级别的个性化权重

约束重排

列表重排