# 1.7.llm\_recommend ## LLM+推荐：概述 ### 一些参考 [A Survey on Large Language Models for Recommendation](https://arxiv.org/pdf/2305.19860.pdf) [Recommender Systems in the Era of Large Language Models (LLMs)](https://arxiv.org/pdf/2307.02046.pdf) 中科大LDS实验室的tutorial：[XadC3O-large-language-models-for-recommendation-tutorial-slides.pdf](https://github.com/daiwk/collections/blob/master/assets/XadC3O-large-language-models-for-recommendation-tutorial-slides.pdf) 对应的datafun talk：[当"狂飙"的大模型撞上推荐系统](https://mp.weixin.qq.com/s/rBGq7rDMK5Vxad5qUmK3nw) [大模型放进推荐系统怎么玩？微软亚研全面总结](https://mp.weixin.qq.com/s/x0qczJ8I8LZ_PyZw2HOI8A) 生成式推荐综述： [Large Language Models for Generative Recommendation: A Survey and Visionary Discussions](https://arxiv.org/pdf/2309.01157.pdf) [A Review of Modern Recommender Systems Using Generative Models (Gen-RecSys)](https://arxiv.org/pdf/2404.00579.pdf) [大语言模型在推荐系统中的探索与应用](https://mp.weixin.qq.com/s/nEhynptVyx8aV8onCwozAA) [一文梳理业界落地LLM4Rec的若干范式-数万字超长文(建议收藏)](https://mp.weixin.qq.com/s/jqFQH6ZYhZRrzilLAo9BiA) [推荐算法月报(2025.2)：大模型的春风吹醒推荐算法，重磅大厂突破](https://mp.weixin.qq.com/s/NO2XgUBiRkjsKNo7dswa0w) [推荐算法(2025.3.4)：速看！阿里Meta的最新研究成果](https://mp.weixin.qq.com/s/1kZCKYbuvd6qiE6-5hJquw) [一文梳理业界落地LLM4Rec的若干范式-数万字超长文(建议收藏)](https://mp.weixin.qq.com/s/jqFQH6ZYhZRrzilLAo9BiA) [推荐系统范式之争，LLM vs. ID？](https://mp.weixin.qq.com/s/7pQ891pnp_BM7qH7ROiWwg) [Exploring the Upper Limits of Text-Based Collaborative Filtering Using Large Language Models: Discoveries and Insights](http://arxiv.org/abs/2305.11700) [知乎的讨论](https://www.zhihu.com/question/630016669/answer/3380909598) ID vs 模态: 推荐系统ID范式有望被颠覆？ [Where to Go Next for Recommender Systems? ID- vs. Modality-based Recommender Models Revisited](https://arxiv.org/abs/2303.13835) [对应的ppt](https://github.com/westlake-repl/MicroLens/blob/master/MicroLens_DeepMind_Talk.pdf) ACL2024的recgpt 这个好像没啥用，[RecGPT: Generative Pre-training for Text-based Recommendation](https://arxiv.org/pdf/2405.12715) [WWW 2024 | 工业界大模型在搜广推场景应用](https://zhuanlan.zhihu.com/p/686259205) [LLM+Recommendation大模型推荐近期进展|含WWW, SIGIR, AAAI等顶会文章](https://mp.weixin.qq.com/s/m8DMgSt_r-HVNHHzA8ceVw) * baidu：[Representation Learning with Large Language Models for Recommendation](https://arxiv.org/pdf/2310.15950.pdf) * huawei：[ReLLa: Retrieval-enhanced Large Language Models for Lifelong Sequential Behavior Comprehension in Recommendation](https://arxiv.org/pdf/2308.11131.pdf) * microsoft：[Knowledge-Augmented Large Language Models for Personalized Contextual Query Suggestion](https://arxiv.org/pdf/2311.06318.pdf) * 阿里：[Modeling User Viewing Flow using Large Language Models for Article Recommendation](https://arxiv.org/pdf/2311.07619.pdf) * linkedin：[Collaborative Large Language Model for Recommender Systems](https://arxiv.org/pdf/2311.01343.pdf) [ClickPrompt: CTR Models are Strong Prompt Generators for Adapting Language Models to CTR Prediction](https://arxiv.org/pdf/2310.09234.pdf) recsys23的[Leveraging Large Language Models for Sequential Recommendation](https://arxiv.org/pdf/2309.09261) 还有一篇[Improving Sequential Recommendations with LLMs](https://arxiv.org/pdf/2402.01339)，对应的代码： meta发的[LLM-Rec: Personalized Recommendation via Prompting Large Language Models](https://arxiv.org/pdf/2307.15780) [生成式推荐系统近期研究工作梳理](https://mp.weixin.qq.com/s/u2kVzgv8ntUIkyCZZXIYWg) [腾讯广告基于混元大模型的生成式召回落地实践](https://mp.weixin.qq.com/s/ClmjgRzpNIVjX0PrikS3qg) [CIKM 2024 | 大语言模型推荐中的协同过滤信号和语义信息的深度融合](https://mp.weixin.qq.com/s/Qd0ZgBqMCJAEjlZYAoy9jQ) [Collaborative Cross-modal Fusion with Large Language Model for Recommendation](https://arxiv.org/pdf/2408.08564) (toread) [生成式推荐最新进展](https://mp.weixin.qq.com/s/IXXMl74ZYpZMINNzFYC8Bg) 25年1月8号写的 [谷歌: 利用推荐知识对齐大语言模型](https://mp.weixin.qq.com/s/62SaQofe9qi2LCApjIzLFA) [Aligning Large Language Models with Recommendation Knowledge](https://arxiv.org/pdf/2404.00245.pdf) 25.10综述：[A Survey on Generative Recommendation: Data, Model, and Tasks](https://arxiv.org/pdf/2510.27157) 25.12综述：[A Survey of Generative Recommendation from a Tri-Decoupled Perspective: Tokenization, Architecture, and Optimization](https://www.preprints.org/frontend/manuscript/9f1a828cd4f9b5f57b729f03832f1c96/download_pub) ### reasoning LLM4rec综述 [大模型时代下的推理型推荐系统最新综述](https://mp.weixin.qq.com/s/VxwmzvTJ65LCnyevmLlTug)：[Towards Reasoning-Aware Recommender Systems: A Survey in the LLM Era](https://www.researchgate.net/publication/397223831_Towards_Reasoning-Aware_Recommender_Systems_A_Survey_in_the_LLM_Era) ### LLM4rec综述 #### 概况 [How Can Recommender Systems Benefit from Large Language Models: A Survey](https://arxiv.org/pdf/2306.05817v6) 基于这个组织 CRM(conventional recommendation models) ![llm-rec-where](/files/JitJhqjN889bmLkXEbge) ![llm-rec-how](/files/UeRDSDTGrmG90Yyh1YHW) #### where-LLM用于特征工程 **user-item level特征增强** 通过LLM的世界知识来获取更好的user/item表示 * [Llama4rec](https://arxiv.org/pdf/2401.13870) ：prompt增强：在prompt里引入推荐模型的信息；数据增强：通过LLM给推荐模型增加样本；adaptive aggregation：llm和推荐模型各自打分并用融合公式融合 * [KAR](https://arxiv.org/pdf/2306.10933)：让LLM总结item得到item emb；让LLM总结user历史得到user emb，两个emb过一个mmoe做融合得到新的两个emb，给推荐模型用 * [SAGCN](https://arxiv.org/pdf/2312.16275)：通过LLM标识出用户对item的评论是属于哪些aspect的，然后u有A个emb，i也有A个emb，构建A个U-I图，然后揉在一起过GCN * [CUP](https://arxiv.org/pdf/2311.01314)：把用户的一堆历史评论扔给chatgpt，让它总结出128个token，然后丢给双塔bert，另一个塔是item的描述，freeze bert底层，只tune上层 * [LLaMA-E](https://arxiv.org/pdf/2308.04913)：instruction formulating为写300个种子指令，让gpt作为teacher，对300个种子指令进行扩展，并由领域专家评估后，去重并保证质量，得到120k个指令作为训练集，再用lora去instruct tuning * [EcomGPT](https://arxiv.org/pdf/2308.06966v1)：设置一系列的task(100多个task)来finetune BLOOMZ，包括命名实体识别、描述生成、对话intent提取等 **instance-level样本生成** * [GReaT](https://arxiv.org/pdf/2210.06280)：把表格化（tabular）数据转成自然语言，然后打乱顺序，自回归地finetune一个LLM，再拿tune完的LLM来合成（synthesize）逼真的（realistic）表格化数据 * [ONCE](https://arxiv.org/pdf/2305.06566)：闭源LLM输出文本（user profiler、content summarizer、personalized content generator），给开源LLM得到user表示，item过开源LLM得到item表示，二者内积学ctr * [Agent4Rec](https://arxiv.org/pdf/2310.10108.pdf)：先训一个推荐模型，然后构建一个多智能体系统，模拟和这个推荐模型交互，产出新的样本给推荐模型做数据增强 * [RecPrompt](https://arxiv.org/pdf/2312.10463)：给一个初始prompt，让LLM1得到推荐结果，拿一个monitor衡量这个结果和ground truth的mrr/ndcg，再用另一个LLM产出更好的prompt给第一个LLM用，如此迭代，得到一个best prompt * [PO4ISR](https://github.com/daiwk/collections/blob/master/posts/\(https:/arxiv.org/pdf/2312.07552\))：给初始prompt，收集error case让模型反思原因并refine出新的prompt，再augment出另一个prompt，并UCB选出最好的prompt，如此迭代 * [BEQUE](https://arxiv.org/pdf/2311.03758)：query重写任务，SFT得到一个LLM，将其预测的若干个候选rewrites通过offline system的feedback得到排序，再通过PRO算法再tune LLM。 * [Agent4Ranking](https://arxiv.org/pdf/2312.15450)：query重写任务，多个人群当成多个agent，每个通过多轮对话产出一个rewrite，再合在一起经过bert+mmoe计算robust损失+accuracy损失。 #### where-LLM作为特征编码器 **表示增强** **统一的跨域推荐** #### where-LLM 用于打分函数 [Text Is All You Need: Learning Language Representations for Sequential Recommendation](https://arxiv.org/pdf/2305.13731) 亚马逊发的 #### where-LLM用于流水线控制（pipeline controller） #### how-tune LLM & infer with CRM #### how-not tune LLM & infer w/o CRM #### how-not tune LLM & infer with CRM #### how-tune LLM & infer w/o CRM ## SID相关原理 ### DSI 参考知乎： [Transformer memory as a differentiable search index](https://proceedings.neurips.cc/paper_files/paper/2022/file/892840a6123b5ec99ebaab8be1530fba-Paper-Conference.pdf)，提出的可微搜索索引（differentiable search index, **DSI**），拆成两个阶段： * indexing：建立**文档**和**doc\_id**的**一一映射** * retrieval：根据query生成候选doc\_ids 与[Autoregressive Entity Retrieval](https://arxiv.org/pdf/2010.00904)提出的**受限beam search**的GENRE（代码，解读[Transformer中PrefixConstrainedLogitsProcessor类的解读](https://zhuanlan.zhihu.com/p/494082642)）对比： * GENRE生成的目标是**有具体语义的实体名** * DSI生成的目标则是**无任何语义的任意doc\_id** #### Indexing方法 * Inputs2Target：即doc\_tokens->doc\_id * Target2Inputs：即doc\_id->doc\_tokens * bidirectional：同时用上两面两个任务，并且在开始时加一个前缀，表明任务的方向 * span corruption：参考T5（[Exploring the limits of transfer learning with a unified text-to-text transformer](https://arxiv.org/pdf/1910.10683.pdf)），将doc\_id当做前缀和doc\_tokens拼起来，2个好处： * 在索引时进行通用的预训练 * 实现doc\_id作为去噪目标和输入的平衡 #### 文档的表示 * Direct Indexing：直接用文档的前L个单词当做文档的表示，并且保留单词的顺序。 * Set Indexing：去掉文档中的重复的单词及停用词，然后和Direct Indexing一样的处理。 * Inverted Index：随机对文档中的连续的k个单词（一个文档块）进行采样，并将它们与doc\_id相关联 #### doc\_id的表示 * 非结构化的原子标识符：直接对所有的文档使用一个随机但互不相同的的整数标识。假设一共有N篇文档需要检索，假设原来解码器输出有V个单词，现在有V+N个单词。 * 朴素的结构化字符串标识符：也使用一个随机的整数，但将这个整数当做一个字符串输出，用受限的beam search搜索前k个文档，因为需要保证**输出的是数字**。 * 语义结构化的标识符：先用BERT产出每个doc的emb，然后**递归10-means**，第一次得到0-9作为第1个数字，第二次的0-9作为第2个数字，可以得到一个树，文档的最终标识符就是从根节点到当前结点的路径对应的编号组合。只要一个节点的文档数大于$$c=100$$，就继续分裂，当叶子的文档数小于c时，每个文档随机分配一个1到$$c-1$$的id，拼到doc\_id的最后。 #### 训练方法 用seq2seq，即**teacher forcing+交叉熵**，有如下两种方式： * 先对indexing进行预训练（memorization），再进行**将query映射为docid**的微调 * 用多任务的方式**同时进行**，两个任务用**不同的标识符**，这样做效果会好很多 后来有一篇[Bridging the Gap Between Indexing and Retrieval for Differentiable Search Index with Query Generation](https://arxiv.org/pdf/2206.10128.pdf)，对应的github：，他也同时尝试复现DSI：，主要有如下两个地方： * 准备数据，doc\_id ```python class IndexingTrainDataset(Dataset): def __init__( self, path_to_data, max_length: int, cache_dir: str, tokenizer: PreTrainedTokenizer, ): self.train_data = datasets.load_dataset( 'json', data_files=path_to_data, ignore_verifications=False, cache_dir=cache_dir )['train'] self.max_length = max_length self.tokenizer = tokenizer self.total_len = len(self.train_data) def __len__(self): return self.total_len def __getitem__(self, item): data = self.train_data[item] input_ids = self.tokenizer(data['text'], return_tensors="pt", truncation='only_first', max_length=self.max_length).input_ids[0] return input_ids, str(data['text_id']) @dataclass class IndexingCollator(DataCollatorWithPadding): def __call__(self, features): input_ids = [{'input_ids': x[0]} for x in features] docids = [x[1] for x in features] inputs = super().__call__(input_ids) # label是doc_id labels = self.tokenizer( docids, padding="longest", return_tensors="pt" ).input_ids # replace padding token id's of the labels by -100 # according to https://huggingface.co/docs/transformers/model_doc/t5#training labels[labels == self.tokenizer.pad_token_id] = -100 inputs['labels'] = labels return inputs ``` * 训练和预测 ```python class IndexingTrainer(Trainer): def __init__(self, restrict_decode_vocab, **kwds): super().__init__(**kwds) self.restrict_decode_vocab = restrict_decode_vocab def compute_loss(self, model, inputs, return_outputs=False): ## 输入文章，预测doc_id loss = model(input_ids=inputs['input_ids'], attention_mask=inputs['attention_mask'], labels=inputs['labels']).loss if return_outputs: return loss, [None, None] # fake outputs return loss def prediction_step( self, model: nn.Module, inputs: Dict[str, Union[torch.Tensor, Any]], prediction_loss_only: bool, ignore_keys: Optional[List[str]] = None, ) -> Tuple[Optional[torch.Tensor], Optional[torch.Tensor], Optional[torch.Tensor]]: model.eval() # eval_loss = super().prediction_step(model, inputs, True, ignore_keys)[0] with torch.no_grad(): # greedy search doc_ids = model.generate( inputs['input_ids'].to(self.args.device), max_length=20, prefix_allowed_tokens_fn=self.restrict_decode_vocab, early_stopping=True,) return (None, doc_ids, inputs['labels']) ``` * 对解码空间的限制： ```python # docid generation constrain, we only generate integer docids. SPIECE_UNDERLINE = "_" INT_TOKEN_IDS = [] for token, id in tokenizer.get_vocab().items(): if token[0] == SPIECE_UNDERLINE: if token[1:].isdigit(): INT_TOKEN_IDS.append(id) if token == SPIECE_UNDERLINE: INT_TOKEN_IDS.append(id) elif token.isdigit(): INT_TOKEN_IDS.append(id) INT_TOKEN_IDS.append(tokenizer.eos_token_id) def restrict_decode_vocab(batch_idx, prefix_beam): return INT_TOKEN_IDS ``` ### vq-vae & rq-vae #### vq-vae [Neural discrete representation learning](https://proceedings.neurips.cc/paper_files/paper/2017/file/7a98af17e63a0ac09ce2e96d03992fbc-Paper.pdf) 用在推荐： [Learning Vector-Quantized Item Representation for Transferable Sequential Recommenders](https://arxiv.org/pdf/2210.12316.pdf) #### rq-vae [Autoregressive Image Generation using Residual Quantization](https://arxiv.org/pdf/2203.01941.pdf) ### 一些tokenizer方法 vq/rq codebook容易坍塌，即马太效应 lfq的熵损失函数能优化codebook利用率，即所有样本的$$-\sum plogp$$，让xx更尖锐？ 然后有个batch内的熵，让xx更平均？ 两个相减可以提升表示能力的同时提升利用率 alit([Adaptive Length Image Tokenization via Recurrent Allocation](https://arxiv.org/pdf/2411.02393))：简单的图片不用那么多token，复杂的多一点 ### TIGER [Recommender Systems with Generative Retrieval](https://arxiv.org/pdf/2305.05065.pdf) 序列推荐的一些paper： * [Session-based recommendations with recurrent neural networks](https://arxiv.org/pdf/1511.06939.pdf)：GRU4Rec首先把RNN用到推荐里 * [Neural attentive session-based recommendation](https://arxiv.org/pdf/1711.04725.pdf)：提出NARM(Neural Attentive Session-based Recommendation)，在GRU里加了attention * [Next item recommendation with self-attention](https://arxiv.org/pdf/1808.06414.pdf)：AttRec在metric learning里引入了self-attention * [Self-attentive sequential recommendation](https://arxiv.org/pdf/1808.09781.pdf)：SASRec用了类似decoder-only的self-attention * [Bert4rec: Sequential recommendation with bidirectional encoder representations from transformer](https://arxiv.org/pdf/1904.06690.pdf)和[Transformers4rec: Bridging the gap between nlp and sequential/session-based recommendation](https://scontent-sjc3-1.xx.fbcdn.net/v/t39.8562-6/246721374_422204999475172_9039387325224382577_n.pdf?_nc_cat=104\&ccb=1-7&_nc_sid=e280be&_nc_ohc=pSC1QwlGTzIAX-yb9Ax&_nc_ht=scontent-sjc3-1.xx\&oh=00_AfApZwRSd9KDBf4b-uGHf3bSS_SsZoRqhYS-lJRZltT97A\&oe=6606DDFA)用了Transformer以及相关的mask策略 * [S3-rec: Self-supervised learning for sequential recommendation with mutual information maximization](https://arxiv.org/pdf/2008.07873.pdf)：在预训练阶段引入了4个自监督的task，4个MIMM(mutual information maximization) * item-attribute MIM * sequence-item MIM：sequence和被mask掉的一个item间 * sequence-attribute MIM * sequence-sequence MIM：sequence和被mask掉的连续item构成的片段间 ![s3-rec](/files/dmhXiJPvIZ6Lty1NkzFW) 这些方法都是学习item的向量，然后用MIPS去ANN，而TIGER(Transformer Index for GEnerative Recommenders)则是生成式地直接预测item的语义id ![tiger](/files/hikH5PUqqeguPVxB9irm) ![tiger-quant](/files/VjEOSOT8Oto4PCnb3dTs) ![tiger-personalized](/files/6l2oaIZcrTdsy4kXvA57) rq-vae的介绍： ![rq-vae](/files/5JlaCbnGu4PAsxMMyE3j) 原图里的下标有一些问题 * $$x$$经过encoder得到的$$z$$（可以看成就是$$r\_1$$），$$l=1$$，在第一个码本里ann找到最近的$$c\_1=1$$，$$z-\boldsymbol{e}\_{c\_1}$$得到$$r\_2$$ * $$l=2$$，$$r\_2$$在第2个码本里ann找到最近的$$c\_2=4$$，$$r\_2-\boldsymbol{e}\_{c\_2}$$得到$$r\_3$$ * $$l=3$$，$$r\_3$$在第3个码本里ann找到最近的$$c\_3=6$$，$$r\_3-\boldsymbol{e}\_{c\_3}$$得到$$r\_4$$ * $$l=4$$，$$r\_4$$在第4个码本里ann找到最近的$$c\_4=2$$，$$r\_4-\boldsymbol{e}\_{c\_4}$$得到$$r\_5$$， * 对应的semantic id就是(1,4,6,2)，拿$$\hat {z} = 1+4+6+2$$再去过decoder得到$$\hat {x}$$ 最终的loss：$$\mathcal{L}*{\text {recon }} + \mathcal{L}*{\text {rqvae }}$$： * $$\mathcal{L}\_{\text {recon }}=|\boldsymbol{x}-\hat{\boldsymbol{x}}|^2$$ * $$\mathcal{L}*{\text {rqvae }}=\sum*{l=1}^L \beta\left|\boldsymbol{r}*l-\operatorname{sg}\left\[\boldsymbol{e}*{c\_l}\right]\right|^2+\left|\operatorname{sg}\left\[\boldsymbol{r}*l\right]-\boldsymbol{e}*{c\_l}\right|^2$$，sg是stop gradient，这里原始的rq-vae是算的$$\mathcal{L}*{\text {commit }}=\sum*{d=1}^D\left|\mathbf{Z}-\operatorname{sg}\left\[\hat{\mathbf{Z}}^{(d)}\right]\right|\_2^2$$看来有点diff * 码本的emb通过moving average更新 rqvae的代码： * VQ部分： ```python class VQEmbedding(nn.Embedding): def compute_distances(self, inputs): codebook_t = self.weight[:-1, :].t() (embed_dim, _) = codebook_t.shape inputs_shape = inputs.shape assert inputs_shape[-1] == embed_dim inputs_flat = inputs.reshape(-1, embed_dim) # a^2 inputs_norm_sq = inputs_flat.pow(2.).sum(dim=1, keepdim=True) # b^2 codebook_t_norm_sq = codebook_t.pow(2.).sum(dim=0, keepdim=True) # (a-b)^2 = a^2 + b^2 - 2ab distances = torch.addmm( inputs_norm_sq + codebook_t_norm_sq, inputs_flat, codebook_t, alpha=-2.0, ) distances = distances.reshape(*inputs_shape[:-1], -1) # [B, h, w, n_embed or n_embed+1] return distances @torch.no_grad() def find_nearest_embedding(self, inputs): distances = self.compute_distances(inputs) # [B, h, w, n_embed or n_embed+1] embed_idxs = distances.argmin(dim=-1) # use padding index or not return embed_idxs @torch.no_grad() def _update_embedding(self): n_embed = self.weight.shape[0] - 1 n = self.cluster_size_ema.sum() normalized_cluster_size = ( n * (self.cluster_size_ema + self.eps) / (n + n_embed * self.eps) ) self.weight[:-1, :] = self.embed_ema / normalized_cluster_size.reshape(-1, 1) def forward(self, inputs): embed_idxs = self.find_nearest_embedding(inputs) if self.training: if self.ema: self._update_buffers(inputs, embed_idxs) embeds = self.embed(embed_idxs) if self.ema and self.training: self._update_embedding() return embeds, embed_idxs ``` * RQ部分 ```python class RQBottleneck(nn.Module): def __init__(...): codebooks = [VQEmbedding(self.n_embed[idx], embed_dim, decay=self.decay[idx], restart_unused_codes=restart_unused_codes, ) for idx in range(self.code_shape[-1])] self.codebooks = nn.ModuleList(codebooks) def quantize(self, x): r""" Return list of quantized features and the selected codewords by the residual quantization. The code is selected by the residuals between x and quantized features by the previous codebooks. Arguments: x (Tensor): bottleneck feature maps to quantize. Returns: quant_list (list): list of sequentially aggregated and quantized feature maps by codebooks. codes (LongTensor): codewords index, corresponding to quants. Shape: - x: (B, h, w, embed_dim) - quant_list[i]: (B, h, w, embed_dim) - codes: (B, h, w, d) """ B, h, w, embed_dim = x.shape residual_feature = x.detach().clone() quant_list = [] code_list = [] aggregated_quants = torch.zeros_like(x) for i in range(self.code_shape[-1]): quant, code = self.codebooks[i](residual_feature) # 就地操作，从residual_feature中减去quant的值，覆盖原来的值 residual_feature.sub_(quant) aggregated_quants.add_(quant) quant_list.append(aggregated_quants.clone()) code_list.append(code.unsqueeze(-1)) codes = torch.cat(code_list, dim=-1) return quant_list, codes def forward(self, x): x_reshaped = self.to_code_shape(x) quant_list, codes = self.quantize(x_reshaped) commitment_loss = self.compute_commitment_loss(x_reshaped, quant_list) quants_trunc = self.to_latent_shape(quant_list[-1]) quants_trunc = x + (quants_trunc - x).detach() return quants_trunc, commitment_loss, codes def compute_commitment_loss(self, x, quant_list): r""" Compute the commitment loss for the residual quantization. The loss is iteratively computed by aggregating quantized features. """ loss_list = [] for idx, quant in enumerate(quant_list): partial_loss = (x-quant.detach()).pow(2.0).mean() loss_list.append(partial_loss) commitment_loss = torch.mean(torch.stack(loss_list)) return commitment_loss ``` ### TIGER应用在排序 [Better Generalization with Semantic IDs: A Case Study in Ranking for Recommendations](https://arxiv.org/pdf/2306.08121) [RecSys'24 | 谷歌:使用语义ID提升推荐系统ID Embed泛化性](https://mp.weixin.qq.com/s/PR8NuRWkK_4vuCrE9xD6Jg) 假设RQ-VAE产出的sid是$$\left(c\_1^v, c\_2^v, \ldots, c\_{L-1}^v, c\_L^v\right)$$，假设每一级的码本都是K，有如下两种用法 * N-gram：N=2，假设不重叠，那就有L/2个子词，每个词对应emb table的一行。每个子词对应的emb table有K^N行，这个emb table和推荐模型一起训练。每个N-gram对应的emb加起来就是这个item的表示 * SPM(sentence piece model)：用SentencePiece对sid进行处理，得到动态长度的子词，流行的共现sid会自动组合为单个subgroup，能同时平衡泛化性和记忆性。 实验部分：内容向量是用videobert产出的2048维，SID的配置：L=8，K=2048。相关推荐场景，有用户历史、当前item和候选item。看随着emb词表变大，auc的变化情况 ![](/files/2iNbDM7LD4f0LziI4o2d) 没有用户历史特征： * 在全量样本上的auc： * 直接用content的dense替换id：和基线一样多层nn时效果很差，把layer数乘1.5和乘2有涨，但仍不如SPM和基线 * n-gram：unigram效果很差，bigram接近layer乘2的效果了，但仍不如SPM和基线 * SPM：和基线差不多 * 在冷启item样本上的auc： * 直接用content的dense替换id：和基线一样多层nn时效果很差，把layer数乘1.5和乘2有涨，乘2时比基线更好 * n-gram：unigram和bigram效果都很差，不如基线 * SPM：超过基线很多 ![](/files/vJqnIrWXBaioBPUaUAm9) 有用户历史特征：不像前面只在当前item/候选item时才有训练，sid的emb有了更充分的训练， * 在全量样本上的auc：SPM超过基线很多，unigram不如基线，bigram超过基线，略低于SPM * 在冷启item样本上的auc：SPM、unigram和bigram效果差不多，都远高于基线，词表较小时n-gram会更好 ### 受限beam search [Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence Models](https://arxiv.org/abs/1610.02424) [Autoregressive entity retrieval](https://arxiv.org/pdf/2010.00904)：代码： [Autoregressive Search Engines: Generating Substrings as Document Identifiers](https://arxiv.org/pdf/2204.10628)：例如一个item可以写成` 1023 Urban Decay Eyeshadow Palette Naked Heat Makeup Eyes `，并通过wavelet tree存储，给定开始token（如``或者``），可以在$$O(Vlog(V))$$里找出所有可能的后续tokens。代码： ## LLM+推荐：输入ID/SID（工业界+落地） ### Meta的HSTU [如何评价Meta最新推荐论文: 生成式推荐打败深度分层架构推荐？](https://mp.weixin.qq.com/s/MeH2drBIBML5OSfCujIJ0Q) [Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations](https://arxiv.org/pdf/2402.17152.pdf) #### 背景 大规模推荐系统依赖高基数(high cardinality)、异质特性(heterogeneous features)，每天要处理上百亿用户行为数据。将推荐系统重新定义为生成模型框架内的序列转化任务，提出HSTU(Hierarchical Sequential Transduction Unit)，专为高基数、非稳态的流式推荐数据设计。 * 在公开数据集比基线NDCG+65.8% * 在8192的序列长度上的处理速度比基于flash attention2的transformer快5.3-15.2倍。 * 1.5万亿（1.5 trillion）参数，线上ab测试指标+12.4% 在[Breaking the curse of quality saturation with user-centric ranking](https://arxiv.org/pdf/2305.15333.pdf)中提到了NCE（normalized cross-entropy）指标： $$ \operatorname{NCE}(p, y)=\frac{\operatorname{CrossEntropy}(p, y)}{\operatorname{Entropy}(y)} $$ ![nce-metric](/files/5XoRIKeSlLIBJxrQZvO8) 可以发现，对于一个预训练好的模型来说，随着时间的变化，NCE的变化是很剧烈的，即数据分布是会漂移的，并不像nlp/cv一样有ground truth，所以传统推荐模型其实很难达到比较好的scaling能力。 ![nce-distribution-drift](/files/cgRrr9OqACCJIAdzCO2B) 需要克服的3个挑战： * 推荐系统中的特征**缺少显式的结构**。序列建模（bert4rec、S3-rec等）在小规模数据集上效果不错，但工业界则需要**异构特征**（高基数的id、交叉特征、统计特征、历史点击率等）。 * 推荐系统使用**十亿规模的动态词表**，而nlp用的是10w的静态词表，要对上万候选进行target-aware操作（din、Cold等），训练和推理的代价很高。 * 大规模序列模型的计算成本是瓶颈。GPT-3在300B token的数据集上用上千个GPU训练1-2个月，而在推荐场景一天就有十亿级的活跃用户和十亿级的候选进行交互，用户序列在极端情况下有近10w（[Twin: Two- stage interest network for lifelong user behavior modeling in ctr prediction at kuaishou](https://arxiv.org/pdf/2302.02352.pdf)），所以推荐系统每天要处理的tokens数量甚至比语言模型1-2个月处理的数量要大几个数量级 本文将**用户action**看成一个新的模态，2个主要的insights： * 给定一个新的特征空间，核心的召回排序任务能被直接转换成生成式模型问题(序列直推任务，sequential transduction tasks) * 这种范式能够系统性地解决传统推荐中的特征冗余、计算冗余、推理冗余，提升效率 #### Sequential Transduction Tasks transductive learning（直推式学习） vs inductive learning（归纳式学习）： * 归纳式学习：训练只使用训练集，不使用测试集，训出的模型对测试集做预测，如监督学习。 * 直推式学习：训练时使用训练集，还使用测试集的特征，但不使用测试集的label， **异构特征的统一表示** * 稀疏特征：itemid、类目、城市、语言、社区等 * 先选出**最长**的时间序列作为**主时间序列**，例如用户的交互序列。 * 剩下的特征随时间变化较慢，如关注作者的属性。对于连续出现的片段（consecutive segment），**只保留最开始的入口**，这样对于主时间序列而言，并不会增加太多的序列长度。 * 数值型特征：这里指的是序列特征里**每个item的统计特征**，比如用户在时刻t对某个item的ctr。直接删了，因为DIN里提到随着序列长度增加，**target-aware**的序列建模方式能够捕捉到这种数值性特征 ![hstu-dlrm-vs-gr](/files/N4YMyX8O8kE9BTijpXFH) 假设用户消费了9个item， * 绿色的有7个时间步，全保留，作为主序列； * 蓝色的有7个时间步，但只有G0和G1两种取值，所以对于连续的G0只保留第0个(出现在t1)，扔到主序列的最前面去，连续的G1也只保留第0个（出现在t8），插到主序列最后一个的前面 * 黄色的全是H0，第0个出现在t7，所以保留t7，往主序列t8前面插入 * 将数值型特征替换为target-aware的cross attention得到causal-masked的特征 * 通过t0、t1、t2（**包括t2**）的特征生成t2的样本，以此类推 **召回和排序的重定义** 输入token序列$$x\_0, x\_1, \ldots, x\_{n-1}$$，输出的token序列$$y\_0, y\_1, \ldots, y\_{n-1}$$是通过mask序列$$m\_0, m\_1, \ldots, m\_{n-1}\left(m\_i \in{0,1}\right)$$得到的。 token对应的动态、非稳态词表是$$\mathbb{X}$$，用户交互的内容是$$\mathbb{X}\_c \subseteq \mathbb{X}$$ * 召回：预估$$p\left(x\_{i+1} \mid u\_i\right)$$，通过时间步i的用户特征预估$$x\_{i+1} \in \mathbb{X}\_c$$，一般是直接选择$$\arg \max \_{x \in \mathbb{X}\_c} p\left(x \mid u\_i\right)$$来最大化**特定的reward**，和标准的自回归有两个不同： * $$x\_i,y\_i$$的label并不一定是$$x\_{i+1}$$，因为用户可以对$$x\_{i+1}$$是负反馈 * $$y\_i$$可能是比如人口属性等（因为是merge的序列，可能把城市之类的merge进来当做一个时间步），这个时候$$y\_i$$未定义的，要把它mask掉，即$$m\_i=0$$ * 排序：推荐中的排序需要在尽量早的阶段进行target-aware的交互，而标准的自回归这种交互往往比较迟，例如在encoder的输出才用上了softmax。因此，设计了一种**target-aware的cross-attention** * 把action和x穿插起来得到新序列$$x\_0, a\_0, x\_1, a\_1, \ldots, x\_{n-1}, a\_{n-1}$$ * 对于action的位置，$$m\_i=0$$ * 对于content位置，使用一个小的nn将预估值转换成多任务的预估值（**感觉是输入0-n，第n项保留**$$x\_n$$**，mask掉**$$a\_n$$**，拿**$$x\_n$$**去多目标地预估用户会用哪个action**） **生成式训练** 假设用户$$i$$有$$n\_i$$个token，那么训练的复杂度就是$$\sum\_i n\_i\left(n\_i^2 d+n\_i d\_{f f} d\right)$$，其中： * $$n\_i^2 d$$是self-attention的复杂度，通过flash attention可以达到$$O(n^2)$$ * $$n\_i d\_{f f} d$$是FFN的复杂度 * 因为要自回归地算，可以理解为batch\_size也是$$n\_i$$，加一个下三角的mask，所以在$$\sum$$里还要乘一个$$n\_i$$ 假设$$N=\max \_i n\_i$$，那复杂度就是$$O\left(N^3 d+N^2 d^2\right)$$，太巨大了 但其实可以发现（这段是自己的理解），假设序列长度9，要预测第4个的时候，4-9的输入是mask掉的，但他们还是要进行后面的attention+ffn计算，其实是很浪费资源的，所以如上面“**异构特征的统一表示**”小节的那个图（生成主序列和辅助序列）所示，该模型直接只吐出x=x1-x3,y=x4作为训练样本就行了，这样既省掉了4-9的无用计算，也更便于并行（相比不拆batch的自回归） 假设采样第$$i$$个用户的概率是$$s\_u\left(n\_i\right)$$，那么总的训练消耗就是 $$ \sum\_i s\_u\left(n\_i\right) n\_i\left(n\_i^2 d+n\_i d^2\right) $$ 如果设置$$s\_u\left(n\_i\right)=1/n\_i$$，那消耗就降到了$$O\left(N^2 d+N d^2\right)$$。而在工业界中要实现这种采样其实很简单，在用户请求或者session结束的时候吐出训练样本就有$$\hat{s\_u}\left(n\_i\right) \propto 1 / n\_i$$了 #### 生成式推荐中的高性能自注意力编码器 ![hstu-arch](/files/cDAWtnEKmdAYqWiNCRM9) HSTU的单层包括3个部分： $$ \text{pointwise\ projection:} U(X), V(X), Q(X), K(X)=\operatorname{Split}\left(\phi\_1\left(f\_1(X)\right)\right) $$ $$ \text{spatial\ aggregation:} A(X) V(X)=\phi\_2\left(Q(X) K(X)^T+\operatorname{rab}^{p, t}\right) V(X) $$ $$ \text{pointwise\ transformation:} Y(X)=f\_2(\operatorname{Norm}(A(X) V(X)) \odot U(X)) $$ 其中， * $$f\_i(x)$$是MLP，$$f\_i(X)=W\_i(X)+b\_i$$ * $$\phi\_1$$和$$\phi\_2$$是激活函数，都是SiLU([Sigmoid-weighted linear units for neural network function approximation in reinforcement learning](https://arxiv.org/pdf/1702.03118.pdf))，其实就是Swish，即$$f(x)=x \cdot sigmoid(x)$$ * $${rab}^{p, t}$$是relative attention bias，考虑了位置$$p$$和时间$$t$$(参考T5论文，[Exploring the limits of transfer learning with a unified text-to-text transformer](https://arxiv.org/pdf/1910.10683.pdf))，其实是在[Self-attention with relative position representations](https://arxiv.org/pdf/1803.02155.pdf)一文提出的 对应到代码()里： ```python self._linear_dim: int = linear_hidden_dim self._uvqk = torch.nn.Parameter( torch.empty((embedding_dim, linear_hidden_dim * 2 * num_heads + attention_dim * num_heads * 2)).normal_(mean=0, std=0.02), ) """...""" batched_mm_output = torch.mm(normed_x, self._uvqk) if self._linear_activation == "silu": batched_mm_output = F.silu(batched_mm_output) elif self._linear_activation == "none": batched_mm_output = batched_mm_output """ 其实就是先乘一个大矩阵，再拆成4份，等价于乘4个小矩阵 """ u, v, q, k = torch.split( batched_mm_output, [self._linear_dim * self._num_heads, self._linear_dim * self._num_heads, self._attention_dim * self._num_heads, self._attention_dim * self._num_heads], dim=1, ) if self._normalization == "rel_bias" or self._normalization == "hstu_rel_bias": if delta_x_offsets is not None: padded_q, padded_k = cached_q, cached_k flattened_offsets = delta_x_offsets[1] + torch.arange(start=0, end=B * n, step=n, device=delta_x_offsets[1].device, dtype=delta_x_offsets[1].dtype) padded_q = padded_q.view(B * n, -1).index_copy_( dim=0, index=flattened_offsets, source=q, ).view(B, n, -1) padded_k = padded_k.view(B * n, -1).index_copy_( dim=0, index=flattened_offsets, source=k, ).view(B, n, -1) else: padded_q = torch.ops.fbgemm.jagged_to_padded_dense( values=q, offsets=[x_offsets], max_lengths=[n], padding_value=0.0 ) padded_k = torch.ops.fbgemm.jagged_to_padded_dense( values=k, offsets=[x_offsets], max_lengths=[n], padding_value=0.0 ) qk_attn = torch.einsum( "bnhd,bmhd->bhnm", padded_q.view(B, n, self._num_heads, self._attention_dim), padded_k.view(B, n, self._num_heads, self._attention_dim), ) if all_timestamps is not None: qk_attn = qk_attn + self._rel_attn_bias(all_timestamps).unsqueeze(1) qk_attn = F.silu(qk_attn) / n qk_attn = qk_attn * invalid_attn_mask.unsqueeze(0).unsqueeze(0) attn_output = torch.ops.fbgemm.dense_to_jagged( torch.einsum( "bhnm,bmhd->bnhd", qk_attn, torch.ops.fbgemm.jagged_to_padded_dense(v, [x_offsets], [n]).\ reshape(B, n, self._num_heads, self._linear_dim) ).reshape(B, n, self._num_heads * self._linear_dim), [x_offsets], )[0] ``` DLRM的3部分： * 特征抽取：常见的基础版本是离散特征pooling，高级版本是din。HSTU本来就能做这种target-aware的attention * 特征交互：常见的使用FMs、DCNv2、DHEN([DHEN: A Deep and Hierarchical Ensemble Network for Large-Scale Click-Through Rate Prediction](https://arxiv.org/pdf/2203.11014.pdf)，引入残差连接)。HSTU通过$$\operatorname{Norm}(A(X) V(X)) \odot U(X)$$来实现，将attention pooled后的结果直接和其他特征算element-wise product。 * 这个做法受[Neural collaborative filtering vs. matrix factorization revisited](https://arxiv.org/pdf/2005.09683.pdf)和[Revisiting neural retrieval on accelerators](https://arxiv.org/pdf/2306.04039.pdf)的启发，用MLP来近似点积是很困难的。原因大概是nn需要调超参和足够的训练数据，在线算得又慢，而且本来内积效果就不错了，nn能带来的边际收益其实不明确。 * 因为$$U(X)$$已经用过SiLU了，所以$$\operatorname{Norm}(A(X) V(X)) \odot U(X)$$可以看成是SwiGLU的变种（参考[Glu variants improve transformer](https://arxiv.org/pdf/2002.05202.pdf)），因为前面在对比LLM激活函数时讲了，$$\operatorname{SwiGLU}\left(\mathbf{x}\_1, \mathbf{x}\_2\right)=\operatorname{Swish}\left(\mathbf{x}\_1\right) \odot \mathbf{x}\_2$$ * 表示转换：常见的如MoE、PLE等，主要思想就是对不同人群用特定的子网络。HSTU里的element-wise product也能达到MoE中的门控操作，只是可能有一个正则化因子的区别。 其实就是原来一般会拆成attention+ffn，而它这3个公式，前两个是attention，第3个就是attention求个norm，然后过一个swiglu的ffn，还有一点，这里的$$U(x)$$是过attention之前的，感觉起到了类似resnet的作用 **pointwise聚合的注意力** 用的是pointwise聚合的注意力，而不是transformer里的softmax，主要有如下两点考虑： * 推荐中item的**强度**信息很重要，softmax会让这种强度失真，导致在预估（如时长）不准；如果只需要预估序，那其实softmax也可以，但推荐要**同时预估序和值**，所以要删掉softmax。 * 虽然softmax对噪声有鲁棒性，但不太适用于流式setting下的非稳态词表。做了一个模拟流式数据的实验，发现只去掉relative attention bias比relative attention bias并加上softmax会好得多 | Architecture | HR @10 | HR @50 | | ------------------------------ | ------ | ------ | | Transformers | .0442 | .2025 | | HSTU ($$-rab^{p,t}$$, Softmax) | .0617 | .2496 | | HSTU ($$-rab^{p,t}$$) | .0893 | .3170 | **增加稀疏性** 使用了一种高效的attention kernel的GPU算子，类似FlashAttention，能够将**融合连续的矩阵操作**（fuse back-to-back GEMMs），但能够 进行fully raggified（可能是不规则，即序列长度可变的？？）的attention计算，本质是将attention计算转换为**不同大小的分组GEMMs**。因此，HSTU变成了memory-bound，并且能够以$$\Theta\left(\sum\_i n\_i^2 d\_{q k}^2 R^{-1}\right)$$进行scale，其中，$$n\_i$$是样本$$i$$的序列长度，$$d\_{qk}$$是attention的维度，$$R$$是寄存器的大小。 受[Deep networks with stochastic depth](/1.7.llm_recommend.md)启发，提出了SL(stochastic length)来增加用户历史序列的稀疏性，推荐系统中的用户行为往往有周期性，并且以不同形式呈现，因此引入稀疏性可以在效果不怎么损失的情况下显著减少encoder的代价，可以scale为$$\Theta\left(\sum\_i n\_i^2\right)$$ 定义$$\Gamma(n, L)$$为一个函数，从原序列$$x\_0, \ldots, x\_{n-1}$$中选出长度为$$L$$的子序列，具体方案如下： $$ \begin{aligned} & x\_0, \ldots, x\_{n\_i-1} \text { if } n\_i \leq N^{\alpha / 2} \\ & \Gamma\left(n\_i, N^{\alpha / 2}\right) \text { if } n\_i>N^{\alpha / 2}, \text { w/ probability } 1-N^\alpha / n\_i^2 \\ & x\_0, \ldots, x\_{n\_i-1} \text { if } n\_i>N^{\alpha / 2}, \text { w/ probability } N^\alpha / n\_i^2 \\ & \end{aligned} $$ 即： * $$n\_i \leq N^{\alpha / 2}$$时，保留原始序列 * $$n\_i>N^{\alpha / 2}$$时，有$$N^\alpha / n\_i^2 < 1$$： * 以$$1-N^\alpha / n\_i^2$$的概率只保留$$N^{\alpha / 2}$$长度的子序列 * 以$$N^\alpha / n\_i^2$$的概率保留原始序列 对于$$\alpha \in(1,2]$$，原来的attention相关的复杂度是$$O\left(N^2 d\right)$$，现在可以降低到$$O\left({N^{\alpha /2}}^2 d\right)=O\left(N^\alpha d\right)$$。 其中的$$\Gamma(n, L)$$经过离线实验（原文附录D里），采用了feature-weighted sampler，即以$$1-f\_{n, i} /\left(\sum\_{j=1}^L f\_{j, i}\right)$$的概率进行采样，其中$$f\_i=t\_n-t\_i$$表示用户和item $$x\_i$$交互的时间和当前的时间差。 对稀疏性的改善如下，其中稀疏性指的是$$1-avg\_seq\_len/max\_seq\_len$$，越大表示短序列越多，即越稀疏($$\alpha=2$$表示不SL，即直接使用原序列)： | Alpha ($$\alpha$$) | seq\_len=1,024 | seq\_len=2,048 | seq\_len=4,096 | seq\_len=8,192 | | ------------------ | -------------- | -------------- | -------------- | -------------- | | 1.6 | 71.5% | 76.1% | 80.5% | 84.4% | | 1.7 | 56.1% | 63.6% | 69.8% | 75.6% | | 1.8 | 40.2% | 45.3% | 54.1% | 66.4% | | 1.9 | 17.2% | 21.0% | 36.3% | 64.1% | | 2.0 | 3.1% | 6.6% | 29.1% | 64.1% | **最小化激活值的内存使用** 在推荐系统中，**大的batchsize**很重要： * 训练吞吐：[Software-hardware co-design for fast and scalable training of deep learning recommendation model](https://arxiv.org/pdf/2104.05158.pdf)一文说的 * 模型质量：[Mixed negative sampling for learning two-tower neural networks in recommendations](https://storage.googleapis.com/gweb-research2023-media/pubtools/pdf/b9f4e78a8830fe5afcf2f0452862fb3c0d6584ea.pdf)、[A simple framework for contrastive learning of visual representations](https://proceedings.mlr.press/v119/chen20j/chen20j.pdf)和[Revisiting neural retrieval on accelerators](https://arxiv.org/pdf/2306.04039.pdf) 因此激活函数的内存占用就成为了主要的scaling瓶颈，这一点和llm不一样，llm一般是用小batchsize，并且内存主要由网络参数占据。HSTU设计了如下方式来减少激活函数的内存占用： * 把attention外的linear layers从6减小到2，同时使用elementwise gating来降低MLP的计算（[Transformer Quality in Linear Time](https://arxiv.org/pdf/2202.10447.pdf)和[Efficiently modeling long sequences with structured state spaces](https://arxiv.org/pdf/2111.00396.pdf)）。第一篇对应的结构如下： ![gated-attention-unit](/files/CArL4FIHGz1ACJGCt6pw) 假设$$d$$是embed size，$$h$$是head数，$$d\_{q k}$$是attention的dim，$$d\_{ff}$$是ffn的hidden size， * 将一些计算融合成一个op，包括$$\phi\_1\left(f\_1(\cdot)\right)$$、layer\_norm、optional dropout和输出MLP，将每一层的激活的内存占用减小到了$$2 d+2 d+4 h d\_{q k}+4 h d\_v+2 h d\_v=14 d$$（以bf16计算，一个参数2字节）---没懂 自己的理解：layer\_norm要存均值+方差，所以要$$2d\times 2bytes$$，所以上面式子就是，U($$2d$$)，V($$2d$$)，Q和K($$4hd\_{qk}$$)，QKV的norm(因为有均值和方差，所以是$$4hd\_v$$)，QKV($$2hd\_v$$) 对比transformer，在attention后用了ffn和dropout，假设中间状态是$$3hd\_v$$，那么ffn包括layer\_norm、linear、激活、linear、dropout，中间状态占用的就是$$2 d+4 d\_{f f}+2 d+1 d=4 d+4 d\_{f f}$$，一般来说，$$h d\_v \geq d$$，$$d\_{f f}=4 d$$， 自己的理解：输入x($$2d$$)，linear($$2d\_{ff}$$)，linear($$2d$$)，dropout(约等于$$1d$$)，layernorm一般是发生在最开始吧，所以应该是第一个$$2d$$改成$$4d$$吧，感觉不是在linear那里变成$$4d\_{ff}$$。。 然后，加上输入的input和input的layer\_norm($$4d$$)，和qkv的映射，总的激活状态是$$33d$$---没懂 所以HSTU的设计能够让scaling达到大于两倍的更深的layers(14d vs 33d) 此外，词表中的id占用了极大的内存，对于10b的词表，512维的emb，Adam优化器，用fp32来存储emb和优化器状态要60TB的内存，因此， * 使用**row-wise的AdamW**优化器（[Training highly multiclass classifiers](https://www.jmlr.org/papers/volume15/gupta14a/gupta14a.pdf)和[FBGEMM: Enabling High-Performance Low-Precision Deep Learning Inference](https://arxiv.org/pdf/2101.05615.pdf)） * 将优化器状态存在DRAM里，从而每一个float在HBM的占用从12bytes降低到2bytes **cost-amortization(摊销)的预估scale up** 对于召回来说，已经有很多加速方法了，例如MIPS的ANN加速，或者OTM等的beam search方法。 对于排序而言，提出了M-FALCON(Microbatched-Fast Attention Leveraging Cacheable OperatioNs)，用于对$$m$$个候选，序列长度为$$n$$的输入进行预估 * 并行计算$$b\_m$$个候选，修改attention masks和$$rab^{p,t}$$ bias，使得这$$b\_m$$个候选的attention操作是完全一样的。从而将cross-attention的计算从$$O\left(b\_m n^2 d\right)$$缩减到了$$O\left(\left(n+b\_m\right)^2 d\right)=O(n^2d)$$，因为$$b\_m$$相比$$n$$要小得多 * (可选)将$$m$$个候选分成$$\left\lceil m / b\_m\right\rceil$$个microbatches，每个batch有$$b\_m$$个候选，从而在如下两个场合利用KV caching([Efficiently scaling transformer inference](https://arxiv.org/pdf/2211.05102.pdf))： * 前向pass中，用于降低消耗 * requests之间，降低长尾耗时 #### M-FALCON详解 ![](/files/e4c2IBjrE9zlbSoTMd2j) 定义： * 输入$$n$$个token $$x\_0, x\_1, \ldots, x\_{n-1}$$，每个token包括item和对应的action，即$$\left(\Phi\_0, a\_0, \ldots, \Phi\_{n\_c-1}, a\_{n\_c-1}\right)$$，也就是$$n=2 n\_c$$ * 精排有$$m$$个候选 $$\Phi\_0^{\prime}, \ldots, \Phi\_{m-1}^{\prime}$$，Micro batchsize $$b\_m$$，可以分成$$\text { numMicrobatches }=\left(m+b\_m-1\right) / / b\_m$$份 * $$\text { attnMask }=L\_{n+b\_m}$$，直接加到attention logit上，是一个下三角矩阵，即下三角是0，其他的是$$-\infty$$；此外，$$\operatorname{attnMask}\[i, j]=-\infty \text { for } i, j \geq n, i \neq j$$，表示大于n的那些item之间是互相看不到的，如下（白色可见，深色不可见）： ![](/files/MwhA9yRiGtQoYtkIj9Lt) 进行一次计算：$$\left(a\_0^{\prime}, a\_1^{\prime}, \ldots, a\_{b\_m-1}^{\prime}\right), k v C a c h e \leftarrow f\left(e m b L a y e r\left(\left(x\_0, x\_1, \ldots, x\_{n-1}, \Phi\_0^{\prime}, \ldots, \Phi\_{b\_m-1}^{\prime}\right)\right), \varnothing, \text { attnMask }\right)$$，其中$$\text { predictions }=\left(a\_0^{\prime}, a\_1^{\prime}, \ldots, a\_{b\_m-1}^{\prime}\right)$$ 算完第一个microbatch后，得到这n个token的kvcache。算下一个microbatch的时候，把这个的microbatch拼到这n个token后面，复用kvcache和attnmask，得到这个microbatch的预估值，以此类推。 **其他** 发现了scaling-law： ![hstu-scaling-law](/files/bfI1103EstuyzuCxyTtZ) ### Meta的sid+ID表征 [\[Meta 2025\]突破推荐系统瓶颈：统一语义与ID表征学习框架全解析](https://mp.weixin.qq.com/s/HOu8nnmL9ntGyGoQofcPSg) [Unified Semantic and ID Representation Learning for Deep Recommenders](https://arxiv.org/pdf/2502.16474) ![](/files/fsIabh3K6xGSjFvQuvVx) ![](/files/kvoM8JApHZAiUxeheHAk) 其实思想很简单，原来推荐id的emb是D维，然后通过RQ-VAE学出一个sid，L个码本，每个码本有K个码，每个码对应D'维的emb（D'大于D），然后D和D' concat起来，当成新的emb丢给推荐模型，注意点： * 联合训练sid与id，即loss=推荐loss+rqvae\_loss+重建loss(encoder输入和decoder输出) * rq中浅层使用cos去检索，深层使用欧氏距离(发现cos更擅长解耦累积的嵌入，而欧氏距离在区分独特物品方面表现更优)，使得性能提升达到6%到17%，同时token大小减少了80%以上。 ### Meta提升id emb稳定性 [Meta广告:提出使用语义ID提升推荐系统ID Embed稳定性](https://mp.weixin.qq.com/s/DIF8ClTyN1y4ah98VR6asw) [Enhancing Embedding Representation Stability in Recommendation Systems with Semantic ID](https://arxiv.org/pdf/2504.02137) 假设总共有H个item id，有L级码本，每一级都是K个取值。c1、c2、c3的功能类比为一级类目、二级类目、三级类目。从semantic id映射到item id有如下几种方法 ![](/files/lFyhR43VYFcCawEJcvd6) * trigram/fourgram：可以理解为十进制数，c1是千位，c2是百位，以此类推 * all bigrams：相邻两个码组合，映射出一个id，那id就是前面的个数加上$$Kc\_i+c\_{i+1}$$，因此，可以映射出好几个id * prefix-ngram：c1得到一个id，c1 c2得到一个id，c1 c2 c3得到一个id，因此可以得到好几个id 后面两种方法得到的id有多个，需要把他们对应的emb sumpooling，得到当前id的emb。对比发现prefix-ngram的效果最好 ### Meta的VISTA [Massive Memorization with Hundreds of Trillions of Parameters for Sequential Transducer Generative Recommenders](https://www.arxiv.org/abs/2510.22049) ![](/files/6IdvRgutkagLIVL8gm7i) ![](/files/BoKNnDAylObBd8S2PLCh) 1. foundation model训练：100k的序列和100的seed序列(learnable的)一起通过一个quasi-linear attn进行训练，并把seed序列的输出存到kv cache里去 2. 下游模型在训练和infer：直接从kv cache取出来，然后和候选item去算target attn。 ![](/files/oH3F57ZKiLZgaBVk4KvR) 1. quasi-linear attn就是先算kv，再去和q搞一下 2. 加了一个生成式的重建loss，让seed序列的表示能力增强，即假设现在是第i个历史序列，那输入完整的长度为k的seed序列，再输入0到i-1个token，经过causal attn后只对0到i-1那几个的输出去预估next item，让seed序列在softmax attn下有预估next item的能力 ![](/files/8hCSopRdectfeMh1hgZ6) 看着是跨地域的同步 ### Meta的Kunlun [Kunlun: Establishing Scaling Laws for Massive-Scale Recommendation Systems through Unified Architecture Design](https://arxiv.org/pdf/2602.10016)，B200的MFU提升：17%->37% Kunlun Transformer： * Generalized Dot-Product Attention (GDPA)：Q是序列特征，KV是非序列特征 ![](/files/JEqURNmAPVbrq9uZTnyl) * self-attn：序列内部的self-attn，看了下论文，应该这部分全是sliding window attn Kunlun interaction： * Weight Generation：输入非序列特征，生成GDPA要的权重 * Hierarchical Seed Pooling(HSP)：将序列表示压缩得到序列summary，有点复杂。。用了PMA（interformer里的，类似perceiver） * Global Interaction：将序列summary和非序列特征一起过多expert的wukong(每个wukong就是一个Linear+FM) Computation Skip (CompSkip)：偶数层跳过self-attn，只算HSP；奇数层跳过HSP和PFFN，计算self-attn Event-level Personalization：点击序列比展现序列更重要，所以对应的序列长度、dim、HSP压缩的token数、window size、层数都更大 看着scale的效果更好 ![](/files/pJDJCJtMNs5hvT8pJeKt) ### Meta的ULTRA-HSTU [Bending the Scaling Law Curve in Large-Scale Recommendation Systems](https://arxiv.org/pdf/2602.16986) ![](/files/ksSDsYgMtRG24zeZ3C0U) * item和action加起来成为一个token，而不像之前hstu ranking是2个token，可以缩短一半的序列长度 * 金字塔堆叠，参考tt电商的onetrans([Onetrans: Unified feature interaction and sequence modeling with one transformer in industrial recommender](https://arxiv.org/pdf/2510.26104))，上层把早期的行为扔掉只对最近的算attn * MoT（Mixture of Transducers）：不同序列过不同的HSTU，然后再merge * 序列是按由近及远组织的，用了如下的semi-local attn，global window是K2，local window是K1 ![](/files/pmvMkeIp3R5vG0MQJSkq) * bf16/fp8的混精度算子融合，同时适配AMD卡（可能能支持异构gpu训练？） ![](/files/pXMFvUqU6FhKXJw47BY4) ### 美团的NLGR 生成式重排 [NLGR: Utilizing Neighbor Lists for Generative Rerank in Personalized Recommendation Systems](https://arxiv.org/pdf/2502.06097) 将邻居候选列表引入生成式reranking框架，结合evaluator-generator策略和非自回归采样机制，使reranker可跳跃组合优化。 ### 美团的SessionRec [SessionRec: Next Session Prediction Paradigm For Generative Sequential Recommendation](https://arxiv.org/pdf/2502.10157) 提出基于 HSTU 架构的“下一会话预测”生成式推荐框架，新增 session 内排序损失，提升候选列表质量。已部署于美团主页面召回阶段，在线 A/B 实验表明相比 baseline 有显著提升。 ### 美团的MTGR [MTGR：美团外卖生成式推荐Scaling Law落地实践](https://mp.weixin.qq.com/s/JiDOqD-ThU0Upp6xnNg3Nw) [推荐算法(2025.5.29)：美团的生成式推荐落地方案](https://mp.weixin.qq.com/s/hQrLSInDnrO5kgCW8I6gCQ) [MTGR: Industrial-Scale Generative Recommendation Framework in Meituan](https://www.arxiv.org/pdf/2505.18654v2) 听说是替换了精排 传统模型： ![](/files/6vNpqeQqFzTN63kBqWB6) 其中： * seq：用户的长期历史序列，静态的 * rt：用户的实时序列，动态的 * cross：历史与当前item交叉后的ctr/cvr ![](/files/EHtX9Oh1IZ66Me1AMch6) * 人口属性组成若干个token放在最前面 * 然后放静态序列seq * 然后放rt序列，注意这里是由近及远地排列，即先发生rt2再发生rt1 * 最后放若干个target（把cross放到candidate里了），也是由近及远地排列 * 堆叠若干层hstu后得到target1、2、3的预估logit mask规则（深色是mask，白色可见）： * 人口属性和静态序列都是可见的 * rt序列未来的看不到现在的，即rt2看不到rt1 * 3个target： * 相互之间仅自己可见 * 由于发生时间可能夹杂在rt1和rt2之间，所以需要按时间戳来决定它们对rt1和2的mask，例如图中的： * 先有target3：但target3比rt2还早，所以它看不到rt1、rt2 * 再有target2：但target2在rt2和rt1之间，所以它看得到rt2，看不到rt1 * 最后有target1：且target1发生在rt2和rt1之后，所以它看得以rt2和rt1 总结一下事件的发生顺序： ```python seq2->seq1->target3->rt2->target2->rt1->target1 ``` ### 美团的MTGRBoost [MTGRBOOST: Boosting Large-scale Generative Recommendation Models in Meituan](https://arxiv.org/pdf/2505.12663) 看着像是MTGR的架构 ### 美团的EGA-V1 [美团UniROM:广告End2End全链路生成式建模范式](https://mp.weixin.qq.com/s/GfuxMwprP5TVSUTBl7Wc6w) [EGA-V1: Unifying Online Advertising with End-to-End Learning](https://arxiv.org/abs/2505.19755) ![](/files/6L4aQahFJK9X402NUz0C) * 传统的特征抽取服务如左图，每个阶段都会rpc请求对应特征 * hfs：user侧只取一次，item侧只保留类别型特征，干掉交叉特征，全库取一次 ![](/files/otkIXnnzpyPrnizQyZlx) * 输入：user长度为L的序列、user和context特征、全库N个候选、最终的K个广告位（slot） * recformer * Global Cluster Former(GCF)：聚类版本的self-attention，通过一个可学习的聚类矩阵将序列长度从$$N$$（候选10w量级，用户序列千级别）压缩到$$N\_c$$（大概100），作为新的K和V，再去和原始的Q(长度为$$N$$)做attention，算完后长度还是$$N$$ * Mid-fusion Interest-Former(MIF)：用户序列和候选序列一起算cluster attention，即互相算一个target attention * 因为是mid-fusion，所以就是比如先2层gcf，再一层mif，这样堆叠 * 最终输出N个候选的表示，和user emb concat一起，过mlp得到预估ctr * aucformer * Non-autoregressive generator(NAR-generator)：$$N$$个候选$$H\_{ad}\in R^{N\times d}$$，$$K$$个广告位$$T\in R^{K\times d}$$，相乘得到分配矩阵$$A=H\_{ad}T^T\in R^{N\times K}$$，结合出价$$b$$得到广告$$i$$在位置$$k$$上的概率：$$\mathrm{z}*{i ; k}=\operatorname{Softmax}\left(\left\[e^{w\_z} \times \hat{q}*j^{\mathrm{ctr}} \times b\_j+\mathbf{A}*{j, k}\right]*{j=1}^K\right)\_i$$）。推理的时候每个slot取得分最高的广告（根据先后顺序去重） * Permutation-aware evaluator：把前面选出来的K个广告的emb，和K个slot的emb，通过GCF+MLP（同样最后会和user emb concat一起，过mlp）得到K个位置的考虑了位置信息和外部信息（user emb）的预估ctr * Payment network：K个广告的emb，evaluator输出的预估ctr，以及除了当前广告外其他K-1个广告的bid，concat起来过mlp，得到最后的预估转化率 训练： * 预训练：除了计算正常下发曝光的K个Item, 还会基于流行度采样$$N\_s$$个样本用于计算整体的损失 * 后训练： * 训练RM：permutation-aware evaluator当做奖励模型，只用曝光样本训练 * RL：基于RM，计算整个list的奖励，看着有点像vcg的东西 * 优化Payment network：引入拉格朗日乘子进行优化 ### 美团的HoMer [推荐算法(2025.10.25)：美团堆更多特征、堆更多上下文，2%效果](https://mp.weixin.qq.com/s/c5Fx867rNsZxgsNBhRu-kg) [HoMer: Addressing Heterogeneities by Modeling Sequential and Set-wise Contexts for CTR Prediction](https://arxiv.org/pdf/2510.11100) ### 美团的MTFM [MTFM: A Scalable and Alignment-free Foundation Model for Industrial Recommendation in Meituan](https://arxiv.org/pdf/2602.11235) ![](/files/HJ13Au9bsir4l7Hlslc6) ![](/files/INqFw4mvWbwzDfF0quCY) 整体看和MTGR很像，H是历史行为序列，R是实时序列，T是target token * 上面的3种token都包括多场景的序列，直接按顺序concat起来，采用图中的mask方式（和MTGR思想类似） * attention部分有2层，都用的GQA，另外还用了GLN（group layer norm），H、R、T分到不同的group里去 * 第一层是full attn，即H、R、T一起做self-attn； * 第二层是target attn，即H和R作为K/V，T作为Q，算attn 整体比较好懂，group layer norm感觉可以参考下 但感觉这种merge序列的方式，如果要加场景，感觉整个模型都得重训，有点不太像一个真正的foundation model ### 美团的MBGR [MBGR: Multi-Business Prediction for Generative Recommendation at Meituan](https://arxiv.org/pdf/2604.02684) ![](/files/7uOFOaPG7OxkXcmfiJKv) 适配多业务，一个是在encoder和sid里把业务id考虑进去，另一个是label的设计，如下图，最后一行是完整的用户序列，第二列的意思就是，我已经发生了A1了，那下一个item如果是A业务，它的label就是A2，如果是B业务，就是B1，以此类推 ![](/files/BdtqNWlh5AYXzgaQEcFU) ### 阿里的HeteroRec [Hierarchical Causal Transformer with Heterogeneous Information for Expandable Sequential Recommendation](https://arxiv.org/pdf/2503.01469) item有各种特征，如title、img、id等 * 左边：异构信息分解（HTFL）把1-T个item的各种特征（每个特征当成一个token）flatten成一个长序列，然后过一个causal transformer得到token粒度的输出list，再过一个item粒度的causal transformer得到item粒度的输出list * 右边：$$2 \sim T+1$$个item，每一种特征把$$2 \sim T+1$$拼到一起过各自的tower，每个tower得到的感觉还是$$2 \sim T+1$$个输出，这个输出和左边的token粒度的输出List算个LMP，然后过一个item cross tower，我猜输出的是$$2 \sim T+1$$个item表示，和左边的item粒度输出List再算一个LMP * LMP：左边是$$1 \sim T$$，右边是$$2 \sim T+1$$，t1过个mlp预测t3，t1过另一个MLP预测t2，即multi-step预估 ![](/files/jDCXHZonH6rcDlQeNB7B) ### 阿里的SORT-Gen [sigir'25「淘宝」多目标重排｜A Generative Re-ranking Model for List-level](https://mp.weixin.qq.com/s/b0PdyR4bFUXhLj9dToBK5A) [A Generative Re-ranking Model for List-level Multi-objective Optimization at Taobao](https://arxiv.org/pdf/2505.07197) 将用户的所有行为聚合成一条样本。每个行为包括四个方面：用户侧、位置、商品侧、精排打分，将行为序列送入tansformer中。 保序回归损失 生成方法：先设计不同的rankscore得到多路序列候选，再比较每一路的top1，决定召回哪一路。 纯价值驱动的列表生成可能有同质化的风险，导致多样性降低。引入相似度惩罚： ### 阿里的GPSD [Scaling Transformers for Discriminative Recommendation via Generative Pretraining](https://arxiv.org/pdf/2506.03699) * 生成式预训练：基于用户行为序列进行自回归生成训练，预测下一个item。 * 判别式训练：使用上面训练的Transformer，除了用户行为序列和target item之外，还输入其他特征，输出正常的分类概率。 提出五种参数转移策略： * no transfer（NT）：从头训练，作为基线。 * full transfer（FT）：转移所有参数（sparse+dense）。 * sparse transfer（ST）：仅转移sparse * FT\&SF：转移所有参数，冻结sparse。 * ST\&SF：转移并冻结sparse。 ![](/files/3Hvj5K8f0bXkV9oWLAlL) 实验发现ST\&SF和FT\&SF效果最好，上线时用的是ST\&SF，可以理解为只是用生成式来训了一下sparse emb，然后freeze住 不过落地的场景比较小 ### 阿里的TBGRecall [TBGRecall: A Generative Retrieval Model for E-commerce Recommendation Scenarios](https://arxiv.org/pdf/2508.11977) 引入了下一会话预测（Next Session Prediction, NSP），将会话和物品进行分区，并采用多会话预测（MSP）和令牌专用网络（TSN）等优化手段 ### 阿里的REG4Rec [REG4Rec: Reasoning-Enhanced Generative Model for Large-Scale Recommendation Systems](https://arxiv.org/pdf/2508.15308v2) ![](/files/1EOpNcCGOfTdvSs4HsKx) ### 阿里的MMQ [MMQ: Multimodal Mixture-of-Quantization Tokenization for Semantic ID Generation and User Behavioral Adaptation](https://arxiv.org/pdf/2508.15281) ![](/files/ktafwgZun6faFDelaMgS) tokenizer训练阶段： * MoE：有共享expert、图片自己的expert、文本自己的expert，三者融合后再过decoder * loss=重构loss（整个item的）+辅助loss（图片和文本各自的）+正交正则loss（专家多样性、避免坍缩）， 其中，重构loss如下，$$e$$是encoder的输入，$$z$$是decoder的输入，$$z\_q$$是和$$z$$的cos最大的code（即下面的hard\_ind）对应的向量(即下面的soft\_ind) $$ \mathcal{L}\_{\text {recon }}=\left|\mathbf{e}-\operatorname{decoder}\left(\mathbf{z}+\operatorname{sg}\left(\mathbf{z}\_q-\mathbf{z}\right)\right)\right|^2 $$ 用户行为finetune阶段： * 通过tokenizer得到对应的code，把code接到推荐模型里，可以适配判别式任务/生成式任务 * loss=task loss+重构loss+正交正则loss ### 阿里的AMEN [Next Interest Flow: A Generative Pre-training Paradigm for Recommender Systems by Modeling All-domain Movelines](https://arxiv.org/pdf/2510.11317) All-domain Moveline Evolution Network (AMEN)： ![](/files/ULjt6CRUCwX5dRxyFsaX) * 生成式预训练：拿判别式模型（transformer）来初始化decoder的权重，输入历史序列，预估未来的T个item，在正常的生成式loss之外还加了： * Velocity：限制模型预估的不要太跳跃，即相邻item尽量像一点：$$\mathcal{L}*{\mathrm{vel}}=\sum*{t=t\_0+1}^{t\_0+T-1}\left|\left(\hat{\mathbf{f}}*t-\hat{\mathbf{f}}*{t-1}\right)-\left(\hat{\mathbf{f}}*{t-1}-\hat{\mathbf{f}}*{t-2}\right)\right|\_2^2$$ * diversity：h个attention head两两的相似度尽量小：$$\mathcal{L}*{\mathrm{div}}=\sum*{t=t\_0}^{t\_0+T-1}\left(\frac{1}{\binom{H}{2}} \sum\_{i=1}^{H-1} \sum\_{j=i+1}^H\left(\operatorname{sim}\left(\mathbf{h}\_i, \mathbf{h}\_j\right)\right)^2\right)$$ * 判别式微调：transformer的输入有如下几部分 * 预训练产出的模型freeze，预估未来的T步，然后当成K和V，target item当成Q，算attn * target item+context（即当前时刻往前若干时间的序列）经过calibration net得到c * 用户特征、1-diversity、第一个预估token的velocity * 判别式增强（TSP，Temporal Sequential Pairwise）：对calibration net加的辅助loss * 直观理解：同样一条t-7到t的序列， * t时刻收藏了书包，没收藏女装，说明应该归因到t-7到t-1里书包和夹克相关的行为，而和t-3到t-1的蜂蜜没啥关系 * t-1时刻把蜂蜜加进购物车，而在t-3时刻进行了搜索、t-2时刻加标签，并没有在t-3时刻收藏蜂蜜 * 但实际loss就是个bpr，即给定一个pair对，正样本的预估分比负样本高得越多越好，而因为每个item是根据历史序列得到的预测，所以变相地鼓励模型通过历史序列来隐式地归因：$$\mathcal{L}*{\text {tsp }}=-\frac{1}{\left|\mathcal{D}*{\text {paired }}\right|} \sum\_{\mathcal{D}*{\text {paired }}} \log \sigma\left(\mathbb{I}\left(y*{t\_1}\right)\left(c\_{t\_1}-c\_{t\_0}\right)\right)$$ ### 阿里的GRC [Learning to Reflect and Correct: Towards Better Decoding Trajectories for Large-Scale Generative Recommendation](https://arxiv.org/pdf/2602.23639) ![](/files/swT37EgdJTP9Ngvn5Ox7) ![](/files/2WRt5O5ICmCSDTslbsSl) ### 快手的RecGPT [RecGPT: Generative Personalized Prompts for Sequential Recommendation via ChatGPT Training Paradigm](https://arxiv.org/pdf/2404.08675) ### 快手的OneRec（非常扯淡） [OneRec: Unifying Retrieve and Rank with Generative Recommender and Preference Alignment](https://arxiv.org/pdf/2502.18965) [OneRec Technical Report](https://arxiv.org/abs/2506.13695) [「快手」全链路统一建模｜OneRec: Unifying Retrieve and Rank with Generative](https://mp.weixin.qq.com/s/wTEWnSe8aFaPiLsnoIeOSA) [效果&成本双突破！快手提出端到端生成式推荐系统OneRec！](https://mp.weixin.qq.com/s/o1Io4j7KsA9tvQX-_JCGwA) 召回排序合为一体的生成式推荐——根据历史session序列，预测下一个session。 ### 快手的OneRec-V2 [OneRec-V2 Technical Report](https://arxiv.org/pdf/2508.20900) 发现v1里encoder很重，改了下，让decoder变得很重 ### 快手的OneLoc [OneLoc: Geo-Aware Generative Recommender Systems for Local Life Service](https://arxiv.org/pdf/2508.14646) ### 字节的LONGER [LONGER: Scaling Up Long Sequence Modeling in Industrial Recommenders](https://arxiv.org/abs/2505.04421) ### 字节的Next-User Retrieval [Next-User Retrieval: Enhancing Cold-Start Recommendations via Generative Approach](https://arxiv.org/pdf/2506.15267) ### 字节的RankMixer [RankMixer: Scaling Up Ranking Models in Industrial Recommenders](https://arxiv.org/abs/2507.15551) [MLP-Mixer: An all-MLP Architecture for Vision](https://arxiv.org/pdf/2105.01601) ![](/files/qUXKi2Sn1H16vGeOVph0) 对于一个序列来讲，有两种混合： (i) 给定的一个位置 (ii) 不同的位置之间，或者和(i)同时进行 对于CNN来讲， * pooling：完成(ii) * 卷积：$$1\times 1$$的卷积完成(i)，$$N\times N$$的卷积完成(ii) 对于transformer来讲， * attention：完成(ii)，即不同位置间的融合 * FFN：完成(i)，即同一个位置内的融合 mlpmixer：明确区分(i)和(ii)，且分别用一个MLP去实现 * 第一层token mixing：做(ii)，即不同位置间的融合 * 第二层channel mixing：做(i)，即同一个位置内的融合 rankmixer v1：只有token mixing；rankmixer-large：token mixing和channel mixing都有了 ![](/files/A8wOw5GF1VgOBRSvvSik) rankmixer的细节： 人工分组：按先验知识，例如user的人口属性是一组，user的短序列行为是一组，对于每一组而言： * 所有特征concat后假设有10000维，以每个token 384维为例，就是切成$$10000/384 +1=21$$个token * 过一层mlp，把384映射成$$21\times 512$$，再split成21个token出来，所以就有21个token，每个是512维 假设有2组，第1组是21个token，第2组是3个token，那总共就是24个token，每个512维，第1层的rankmixer如下： * mixup转置，new\_tokens假设是16，那每个新token就是$$24\times 512/16=768$$维 ```python def mixup(x, new_tokens=16): # 输入[bs, 24, 512]，最终输出[bs, 16, 768] # [bs, 24, 512] bs, token_num, dims = x.get_shape().as_list() # 512/16 * 24 = 768 new_dim = dim // new_tokens * token_num # 先把[bs,24,512]改成[bs, 24, 16, 512/16] output = tf.reshape(x, [-1, token_nums, new_tokens, dim // new_tokens]) # 把[bs, 24, 16, 512/16]改成[bs, 16, 24, 512/16] output = tf.transpose(output, [0, 2, 1, 3]) # 把[bs, 16, 24, 512/16]改成[bs, 16, 768] output = tf.reshape(output, [-1, new_tokens, new_dim]) return output ``` * 搞16个独立的FFN，每个可以是$$768->768\*2->768$$这两层的mlp（当然，还有很多别的变种，这里就不说了） 第二层也是先mixup转置，例如你设置8个new\_tokens，那就对应8个独立的FFN 最后一层的输出，取mean pooling，再送到后面的网络去 [AutoInt: Automatic Feature Interaction Learning via Self-Attentive Neural Networks](https://arxiv.org/pdf/1810.11921)这个好像也提了pertoken pertoken ffn+qkv是[Hiformer: Heterogeneous Feature Interactions Learning with Transformers for Recommender Systems](https://arxiv.org/pdf/2311.05884)里提出来的 onetrans的前身：[InterFormer: Effective Heterogeneous Interaction Learning for Click-Through Rate Prediction](https://arxiv.org/pdf/2411.09852) ### 字节的R3-VAE [R3-VAE: Reference Vector-Guided Rating Residual Quantization VAE for Generative Recommendation](https://arxiv.org/pdf/2604.11440) 头条的GR ### Pinterest的PinRec [PinRec: Outcome-Conditioned, Multi-Token Generative Retrieval for Industry-Scale Recommendation Systems](https://arxiv.org/pdf/2504.10507) [Pinterest最新干货PinRec:生成式检索在推荐系统的落地实践](https://zhuanlan.zhihu.com/p/1927696466241093671) ![](/files/FfdbgmoSeq84qz507iPY) 用户的历史序列如上图，有item也有query，还有对应的场景。 item表示：没有直接用itemid的emb，也没有用sid。对于query，用[OmniSearchSage: Multi-Task Multi-Entity Embeddings forPinterest Search](https://dl.acm.org/doi/pdf/10.1145/3589335.3648309)(其实就是个bert，不过和item一起拿用户行为训练过了)得到一个训练好的emb；对于item，用pinsage的表示。后面都会接2-3层mlp。此外，还有个item id的可学习的emb 经过transformer之后，最后一层的hidden state，和下面的“条件”一起concat起来过一个mlp得到item的表示 结果条件生成： * 每种action（点击、保存等）学一个emb * 训练时拿t+1的action作为t的额外输入，即期望下一时刻看到这种action的item * infer时把每种action都作为输入去分别召回，然后按给定的不同action的权重比例进行merge MTP：有点绕，大概意思就是现在是时间$$t$$，在后面的$$\[t+1, t\_{lim}]$$里采样出一个$$t'$$，然后找到$$\[t', \Delta]$$这个窗口里和user最近的那个item（就公式里的min）拿来加到loss里去 $$ \begin{aligned} & L\_\theta^{\operatorname{mt}}\left(H\left(u, t\_{\max }\right)\right)= \\ & \quad \frac{1}{\left|H\left(u, t\_{\max }\right)\right|} \sum\_t \mathbb{E}*{t^{\prime} \sim p*{t^{\prime}}(\cdot \mid t)}\left\[\min \left{L\_s\left(\hat{\mathbf{i}}*{u, t}, \mathbf{i}*{u, i}\right) \mid \forall i \in\left\[t^{\prime}, t^{\prime}+\Delta\right]\right}\right] \end{aligned} $$ ### Pinterest的PinFM [推荐算法(2025.7.19)：Pinterest出品必是精品——GPT建模行为序列](https://mp.weixin.qq.com/s/APOHCngQR5Dt_o4rNCCMbg) [PinFM: Foundation Model for User Activity Sequences at a Billion-scale Visual Discovery Platform](https://arxiv.org/pdf/2507.12704) ![](/files/3eAtZoARRsO1sAlUH61Q) #### 预训练 两年用户数据，序列最长16k，切成多个小段，每段长度$$L$$是几百。模型用的是带pre-ln的gpt2(decoder only)，也试过hstu，效果类似，基于info-nce设计了3个loss * ntl（Next Token Loss）：下一个正样本 * mtl（Multi-Token Loss）：未来$$L'$$个正样本 * ftl（Future-Token Loss）：最终要用到下游任务里，但那些任务的序列的长度$$L\_d$$较短，所以从第$$L\_d$$个开始预测mtl #### 微调 有2种融合方式： * late fusion：基于用户历史序列产出用户emb，和其他特征一起输入精排 * early fusion：将候选item加到用户序列里，实时产出用户emb，再和其他特征一起输入精排（采用这种方案） 一些技巧： * 微调时除了精排的二分类loss，可以加入ntl和mtl辅助loss * 把pretrain部分（user序列）的学习率设置为精排的1/10，以保留预训练知识。 * pretrain部分的输出同样接了网络预估精排目标，这个logit和正常精排的logit算mse来对齐 冷启item优化： * 10%的概率针对候选item随机选一个id * 如果item是最近x天的item，pretrain部分的输出加上dropout #### serving DCA(Deduplicated Cross-Attention Transformer)：user的历史序列当成context，把每层的kv cache存起来，然后和候选item算cross attention就行了。这里的去重是batch维度的，即一个batch里会有不少同一user的相同序列，只保留一份去算kv cache，然后再还原回去，每条instance去算cross attn。serving时可以理解为就是broadcast 用torchrec来实现分布式的emb table，每个item对应256维emb，拆成8个子向量，每个32dim。用FBGEMM的n-bit min-max量化算子，并加上了ptq量化，把32dim的fp16量化成了32个int8/int4+1个fp16的scale value + 1个fp16的bias value。在int4的情况下，每个vec从512bit压缩到了160bit，降低了31.25%的emb table。 ![](/files/MGWFgXtBkqfnYsDAWUt4) ### 小红书的GenRank 最开始叫rankgpt，后来改名了，GenRank [小红书RankGPT:推荐系统生成式精排的落地实践](https://mp.weixin.qq.com/s/2D31iyO07DNdTBPdHp-3Qw) [Towards Large-scale Generative Ranking](https://arxiv.org/abs/2505.04180) [「小红书」生成式方案｜Towards Large-scale Generative Ranking](https://mp.weixin.qq.com/s/C4CKr4jfm_f799KCeyFrSw) ![](/files/wOZSn3eOqy0J9ksQLUh3) * hstu是item和action当成2个token，输入历史item+action，对于候选item，预估其action * genrank把item和action合成一个token（两者的emb相加），输入历史item+action，对于候选item+masked action，预估其action ![](/files/etLY5DNhnTl5EwzKe0zn) mask：target之间互相不可见，但每个target都能看到所有历史 还设计了一些特殊的位置emb，全部加起来，和item emb以及action emb也加起来： * 位置emb：下标的emb * 请求索引：同一时间请求的item用同一个下标表示 * 请求前时间emb：历史每个item和当前时间的时间差，分桶 另外，这种方式位置Embed和时间Embed是独立设计的, 缺少了两者的交叉，还引入了ALiBi位置编码, 即在注意力计算时, 引入一个常数bias： ![](/files/0sXD35sqPMDY8dE5O702) ### 百度的COBRA [Sparse Meets Dense: Unified Generative Recommendations with Cascaded Sparse-Dense Representations](https://arxiv.org/abs/2503.02453) ![](/files/YMznducDpqEOtfqDlWuz) 和tiger很像，主要区别是除了原来rq的code，还加了个dense emb进去 ![](/files/eDsKpvDkC5u6Ci3kStk5) rq部分freeze，dense是拿item的明文特征过一个bert得到的cls emb，bert是训练的 decode出来有两个东西，rq的code和dense ![](/files/0rja6Rsm6X7klrwljpy9) * 先beam search出m个rq的code出来 * 然后每一个code和原来的seq一起输入decoder，得到的pred就是dense，再拿这个dense去ann找n个item * 最后对这m\*n个item拿两个相似度融合出一个得分，取topk出来 ### 百度的“心流” [百万美金背后的推荐技术突破，内部揭秘2025年百度最高奖获奖“心流”团队的背后故事](https://mp.weixin.qq.com/s/O4iqt1ADCWwKNEq0hCyMrg) [让推荐更懂你：百度2025最高奖‘心流’团队的标题改写实战](https://mp.weixin.qq.com/s/IDzjnXMw9NXHZXZue7RQKQ) ### 百度的GRAB [GRAB: An LLM-Inspired Sequence-First Click-Through Rate Prediction Modeling Paradigm](https://www.arxiv.org/pdf/2602.01865) ![](/files/ylQQZuF7zOaN9lzAGh0B) 输入多个用户的序列，过统一的trans，然后目标好像不是自回归，应该是ranking ![](/files/hAUrCiNoLFcNZCpq7hOZ) 序列压缩，把不同用户的序列合并成一条序列，然后加上对应的mask，保证用户间不可见，用户内causal ![](/files/fDcusjAamLuNcBOnfCVx) 单用户内部，每一个item又拆成了2个token： * partial token：图中的h，只保留随时间变化、对刻画历史有用的信息（例如context、相对位置/时间），把静态或高度重复的字段丢掉（例如user\_id、长期稳定兴趣），只能看到t-1时刻往前的partial和自己 * full token：图中的h'，保留打分所需的完整信息（例如uid+target itemid），只能看到t时刻往前（图中可能漏了t时间）的partial和自己，看不到其他所有full ![](/files/3IUhyKlzPSZFOfy5VSlX) rab（time+pos+action），然后带上滑窗mask（即q只能看到前面若干长度的k） ### 腾讯的GPR [GPR: Towards a Generative Pre-trained One-Model Paradigm for Large-Scale Advertising Recommendation](https://arxiv.org/pdf/2511.10138) ![](/files/ICLWlKKwgSB9QN77T0QH) 先用RQ-Kmeans得到一个高质量的码本，然后拿这个去初始化，然后再走正常的RQ-VAE，还在encoder里加了个残差，可以使训练更稳定&提升码本利用率 ![](/files/PIWwt5Dh4kuag8Q2tkAD) * decoder输入的一个token包含4部分，u-token(user属性)、O-token(organic content，应该是体裁/场景之类的东西)、E-token（环境，例如设备、位置等）、I-token（item内容，用RQ-Kmeans+生成的sid表示），然后有如图的attn mask，decoder里会搞个token-aware FFN * decoder的最后一个输出emb，先输出几个thinking tokens，并通过refining module(类似扩散模型)，最终产出一个refine token * 拿这个refine token去生成下一个sid，生成的过程是value-guided trie-based beam search，这里的value是HTE（Hierarchical Token-wise Evaluator）的预估分，HTE通过如下方法训练 ![](/files/F6zJR2eoRsyLO0Sk4joL) * 预训练:用mtp的方式 * value-aware finetuning：不同action有不同value(例如展现=1，点击=2，转化=4)，对mtp每个token的loss加权 * RL：把训好的gpr部署在生产环境和模拟环境里（定期同步）， * 模拟环境中：用GPR产出k=40个item，然后请求该环境中的精排和后链路拿到打分，算一个融合分当成reward，这个其实是最细的那一级sid的reward * 考虑流行度等因素把这个item粒度的reward细拆到每一级的sid上，同时训练HTE来给出每个value的预估，并和reward算loss 还搞了Anticipatory Request Rehearsal (ARR)，来避免模型过拟合到历史数据上，即自己构造数据去请求模型得到样本，U-token复用，O-token拿用户最近的一个场景/体裁，E-token实时请求最新的，不同活跃度用户的构造频率不同 ### 腾讯的S-GRec [S-GRec: Personalized Semantic-Aware Generative Recommendation with Asymmetric Advantage](https://arxiv.org/pdf/2602.10606) ![](/files/DwMBAFsUTCsXV1oGUx6S) 在GR里加了一个LLM as Judge产出语义reward，加上业务指标的reward一起RL ![](/files/ZtKZRpOuQ2pdzVYox6RT) PSJ(Personalized Semantic Judge)：产出semantic reward * part a：Aspect-level Semantic Scoring：给定u+ad，产出4个分数（用户profile相关性、未来兴趣相关性、新颖性、请求时上下文相关性）。标注流程包括线上样本->llm标注->人工检查->prompt修正。训练先SFT，再GRPO * part b：User-conditional Preference Aggregation：part a里有4个分数，每个用户有4个权重，融合成一个分。构造pairwise数据，同用户不同ad的偏好，然后用group-wise grpo去学这个权重 ![](/files/kYVzV47WXR8ckUw7MOR3) * 左边是正常的GRPO，会把2个reward加起来，一起算mean和std，再去算advantage * 右边是A2PO（Asymmetric Advantage Policy Optimization），2个reward各自算advantage，然后按下式融合（商业价值为主，只有当2个reward正负号一致时semantic reward才生效） ![](/files/Fk9KCFbdPxMoECNYwYS9) 注意，这里的GR是用的minionerec([MiniOneRec: An Open-Source Framework for Scaling Generative Recommendation](https://arxiv.org/pdf/2510.24431))，是个sid+LLM的生成式框架 ### 腾讯的OneRanker [OneRanker: Unified Generation and Ranking with One Model in Industrial Advertising Recommendation](https://arxiv.org/pdf/2603.02999) ![](/files/JuPmjwHKwniQN0imJsMe) ![](/files/HXqjNO2azd9q77h3CSJV) GPR的延续，模型包括召回（step1+2）和排序（step3）部分， * step1 生成：输入GPR的异构token序列，产出K/V，长度是用户历史的长度。4层trans * step2 task/target Aware：Q是具体task token(m个推荐任务和1个商业任务)和聚类信息（图中的fake item，即kmeans后的k个聚类中心），和上述K/V算attn，2层trans * 产出task数个双通道表征(图里的head-v部分)：task自己的表示，task和所有fake item交互一下 * 通过MTP生成n个item * step3 排序：一层trans * k/v：step1的k/v和step2的双通道表征，共历史长度+task数个token * q：一个特殊的task token ### Shopee的OnePiece [OnePiece: Bringing Context Engineering and Reasoning to Industrial Cascade Ranking System](https://arxiv.org/pdf/2509.18091) [知乎](https://www.zhihu.com/question/1906473225224953962/answer/1956667989328888901) ![](/files/CNMkn3Y2mlfiIUWUIlB2) ![](/files/00mgrBvLT3unNEAS4Dfc) ![](/files/zsOgR9jR4TlK0ybiNQCJ) ### 网易云音乐的Climber [Climber: Toward Efficient Scaling Laws for Large Recommendation Models](https://arxiv.org/pdf/2502.09888) cikm2025 best applied paper ### 网易云音乐的Climber-Pilot [Climber-Pilot: A Non-Myopic Generative Recommendation Model Towards Better Instruction-Following](https://arxiv.org/pdf/2602.13581) ![](/files/2L6GD8jmRSNvt9cSeuM1) 预训练： * TAMIP（TimeAware Multi-Item Prediction）：如右下角，就是一个mtp，自回归的，每个item都会预测一下，即item 6会预测item 7，也会预测item 8 * time-aware masking：时间差小于xx的mask掉（让模型看不到非常近的item，防止追打） SFT：加了个condition instruct(流行、古典、R\&B等)，如右上角，只拿最后一个位置去预估，还会输入该位置的condition，同样是MTP ![](/files/s5mi3nESCAJusGTlhuyX) serving如图，用户序列会存好kv cache，然后根据多个condition，生成多个的预估emb，再去分别ann召回再merge 3层trans,emb dim=128，时间差设置为15min，MTP只预测2个分支 ### Yandex的ARGUS [Scaling Recommender Transformers to One Billion Parameters](https://www.arxiv.org/pdf/2507.15994) Yandex的音乐推荐场景 ![](/files/QfdBoaXDysCURlGJUDAP) 预训练：输入f(feedback)、i(item)、c(context)，emb相加，过transformer得到h * 召回任务：concat(h,c)接一个mlp预估next item * 精排任务：concat(h,c,下一个i)接一个mlp预估feedback 微调：主要的下游任务是排序，参考pinnerformer，设计了双塔，输入和预训练一样也是f、i、c，输出的h就是user表示，然后和item算内积得到相似度，再过pointwise或者group wise的排序loss ![](/files/a5xYYn5LmftA2rRHlR4r) ### 亚马逊的UniRec [UniRec: Bridging the Expressive Gap between Generative and Discriminative Recommendation via Chain-of-Attribute](https://arxiv.org/pdf/2604.12234) ![](/files/HVP9FPxK4G7hpshOCNz4) #### Capacity-constrained Semantic ID 之前的方法可能能做到每个code下item数均衡，但还是会有马太效应，即最终充分训练的还是高热的那些。统计到：top 10%的s0 token只占33.24%曝光，但到(s0,s1)组合就占到87.90%，到(s0,s1,s2)组合更到89.62%。也就是说，越往后层，流量越集中到极少数路径上。 搞了两阶段的贪心策略： * 聚类：将item分到离自己最近的聚类中心，重构误差小 * 超载修复：约束每个cluster承担的总曝光量V不超过设置的上限，如果超了，就把它里面的item挪到新的cluster里去，保证尽量近&新cluster的容量不超上限 ![](/files/sr4zeUnK1qMNGShFQbIu) #### Chain-of-Attribute 大家都认为判别式任务同时输入了u和i，上限应该比生成式高，因为生成式只输入了u，但作者分析了一下： 用户u，item f（共n个特征），label y，首先有$$p(y|f,u)p(f|u)p(u)=p(f|y,u)p(y|u)p(u)$$，然后转换一下就是$$p(y|f,u) = p(f|y,u)p(y|u)/p(f|u)$$，此时因为我们看的是给定u和f时，y的概率，所以$$p(f|u)$$是个常量，可以忽略，那就是 $$ p(y \mid \mathbf{f}, u) \propto p(\mathbf{f} \mid y, u) p(y \mid u) $$ 而此时$$p(y|u)$$和item无关，所以判别式的打分等价于生成一个完整item的打分。根据链式法则，那就可以拆到这n个特征的每一个上来 $$ p(\mathbf{f} \mid y, u)=\prod\_{k=1}^n p\left(f\_k \mid f\_{\`（广告）和``（自然结果）这两个special token，拼到每个item的第一个sid前面 * 训练就是正常训，没啥特别的，只是说那个特殊token使得它后面的sid点像条件概率 * infer引入bid敏感性 * ``这个词的logit加上所有广告候选的max bid做扰动：$$\tilde{z}*{\langle\mathrm{AD}\rangle}=z*{\langle\mathrm{AD}\rangle}+\lambda \cdot \log \left(1+b\_{\max }\right)$$ * 后面的sid在decoding的时候，每一级sid都加上当前cluster的max bid做扰动：$$\tilde{z}\_c=z\_c+\lambda \cdot \log (1+\mathcal{B}(c))$$ 另外，论文的实验用的是一价计费，说是最近各大公司都在往一价迁？ ### Meta的DTI [Towards An Efficient LLM Training Paradigm for CTR Prediction](https://arxiv.org/pdf/2503.01001) ![](/files/opXllbDzzB3JyuXWQGGi) 。。好像没啥，就是预测未来k个，并且设计了滑动窗口的mask（右下角） ### Meta的RPG [Generating Long Semantic IDs in Parallel for Recommendation](https://arxiv.org/pdf/2506.05781) ![](/files/Fgs5pipzdhKDVEfuZUrN) 训练： * 长语义ID（SID）构造：使用OPQ(optimized pq)将物品特征（文本、图像等）编码为SID（最多64个token），每个token来自不同codebook，编码物品语义子向量。相比RQ，OPQ没有token间的顺序依赖，适合并行生成，且信息分布更均衡。 * 多token预测（MTP）：通过MTP损失函数，并行预测语义ID的所有token infer： * 图构建：将每个SID的64个token的embedding通过mean/max pooling成一个语义embedding。使用faiss存储这些embedding，并为每个语义ID搜索top-k个最相似的SID，作为图的边，构建一个的解码图。 * 迭代图传播：随机初始化b个SID beam，从这b个节点出发，沿图传播，从相邻的SID里保留得分最高的b个ID。迭代q次，生成最终的top-K推荐列表。 ### 美团的EGA-V2 [EGA-V2: An End-to-end Generative Framework for Industrial Advertising](https://arxiv.org/abs/2505.17549) ### 美团的DFGR [Action is All You Need: Dual-Flow Generative Ranking Network for Recommendation](https://arxiv.org/pdf/2505.16752) ### 华为的UniGRF [Killing Two Birds with One Stone: Unifying Retrieval and Ranking with a Single Generative Recommendation Model](https://arxiv.org/pdf/2504.16454) [sigir‘25「华为」统一召回+排序框架](https://mp.weixin.qq.com/s/eKU_AlffGR1Lx_wQspuLpQ?poc_token=HEPlGGijUUqAuU1VTCkeSPkWDfZG99B1eN5xtLkh) ### SnapChat的GRID（框架） [推荐算法(2025.10.9)：Snap说：做GR推荐的同行们，你们走错方向了](https://mp.weixin.qq.com/s/2G3-Moegkx5x8f0Yt0gCVw) [UNDERSTANDING GENERATIVE RECOMMENDATION WITH SEMANTIC IDS FROM A MODEL-SCALING VIEW](https://arxiv.org/pdf/2509.25522) [Generative Recommendation with Semantic IDs: A Practitioner's Handbook](https://arxiv.org/pdf/2507.22224) 基于的这个模板： 新论文介绍了落地情况：[Semantic IDs for Recommender Systems at Snapchat: Use Cases, Technical Challenges, and Design Choices](https://arxiv.org/pdf/2604.03949) #### RQ-VAE回顾 encoder把输入的d维向量映射成n维，有L级code，每一级有K个取值，第0个codebook的第0个sid code就是 $$ \operatorname{sid}\_0=\underset{c \in{0,1, \ldots, K-1}}{\arg \max }\left|\mathbf{h}\_i^0 \cdot \mathbf{C}*0\[c]\right|*{\mathrm{F}}, \text { with } \mathbf{h}\_i^0=\operatorname{Enc}\left(\phi\left(x\_i\right)\right) $$ 然后第l个code如下，其中$$\mathbf{h}*i^l=\mathbf{h}*i^{l-1}-\mathbf{C}*{l-1}\left\[\operatorname{sid}*{l-1}\right]$$ $$ \operatorname{sid}\_l=\underset{c \in{0,1, \ldots, K-1}}{\arg \max }\left|\mathbf{h}\_i^l \cdot \mathbf{C}*l\[c]\right|*{\mathrm{F}} $$ 最终再decode回去就是 $$ \hat{\mathbf{h}}*i=\operatorname{Dec}\left(\sum*{l \in{0, \ldots, L-1}} \mathrm{C}\_l\left\[\operatorname{sid}\_l\right]\right) $$ 有2个loss，一个是重建loss，一个是commitment loss（拉近h和c的距离） #### 挑战 挑战1：码本坍塌（Codebook Collapse）：模型只利用了码本的一小部分，设计了2种方式： * STE（straight-through estimator）：直接更新整个码本，原始RQ-VAE是只更新argmax出来的那个code，这种稀疏更新方式很依赖码本的初始化。最原始的VQ-VAE论文([Neural Discrete Representation Learning](https://proceedings.neurips.cc/paper_files/paper/2017/file/7a98af17e63a0ac09ce2e96d03992fbc-Paper.pdf))里也用到了，另外这里也有。STE如下，其中$$\operatorname{sim}\left(\mathbf{h}\_i^l, \mathbf{C}\_l\right) \in \mathcal{R}^K$$表示cos相似度 $$ \hat{\mathbf{h}}*i=\operatorname{Dec}\left(\sum*{l \in{0, \ldots, L-1}} \mathrm{C}\_l\left\[\operatorname{sid}\_l\right]+\operatorname{sim}\left(\mathbf{h}\_i^l, \mathbf{C}\_l\right) \cdot \mathbf{C}\_l-\operatorname{sg}\left\[\operatorname{sim}\left(\mathbf{h}\_i^l, \mathbf{C}\_l\right) \cdot \mathbf{C}\_l\right]\right) $$ * 基于多个embed来源来学习sid：例如图片emb、文本emb、meta数据对应的emb等，多个emb进行merge： $$ \mathbf{h}*i=\sum*{m \in M} \operatorname{Enc}*m\left(x\_m\right) \text { and } \hat{\mathbf{h}*{i, m}}=\operatorname{Dec}*m\left(\sum*{l \in{0, \ldots, L-1}} \mathrm{C}\_l\left\[\operatorname{sid}\_l\right]\right) $$ 挑战2：SID-to-Item Resolution：同一个sid对应的一堆item如何消歧 * 基于启发式方法的代码内消歧：其实就是加一些人工规则排序，例如后验/新鲜度等 * 考虑检索深度而非广度：方案a只取少量的top sid，每个sid拉很多item出来；方案b取很多sid，每个sid只拉一点item出来，方案a效果更好 #### 在线实验 * sid作为辅助特征： * 广告排序：item文本信息过qwen得到emb，再搞成sid丢给精排 * 好友推荐和搜索排序：用[GraphHash: Graph Clustering Enables Parameter Efficiency in Recommender Systems](https://arxiv.org/pdf/2412.17245)搞了个基于模块度的Louvain方法做社区发现，将uid映射成多级社区的id表示（类似sid），当成特征加进排序模型 * sid做GR召回：在之前的文章[Generative Recommendation with Semantic IDs: A Practitioner's Handbook](https://arxiv.org/pdf/2507.22224)里讲了模型细节，效果如下：拉长序列指标有涨，前面讲的方案a比方案b更好，启发式的规则排序能带来业务指标收益 ![](/files/Pi7i4zzq1dXvwT0g2K4B) * sid质量评估：uniqueness表示unique used SIDs / total number of items，其实就是衡量sid冲突严重程度的指标。发现这个值和recall\@k并不是完全正相关，比较低的时候有这个趋势，但达到一定阈值的时候，uniqueness继续涨，recall\@k基本平了 ## LLM+推荐：输入文本（工业界+落地） ### Google的2个LLM [谷歌短视频推荐:用户反馈对齐的LLM用于新颖推荐](https://mp.weixin.qq.com/s/ff34lzbbTVREQG6FSpdgeg) #### novelty LLM [Llms for user interest exploration in large-scale recommendation systems](https://arxiv.org/abs/2405.16363) 对llm进行sft，输入用户喜欢的K个cluster，预测下一个cluster。 ![](/files/AP1vjz1ukKfMvcRAORr7) cluster包括了一系列短语，如(猫，狗，动物，宠物，小动物)可能是一个cluster，(船，轮船，皮划艇，独木舟)可能又是另一个cluster。使用的2级cluster，共761个取值。 基于gemini进行sft，拿7000多个样本（每个$$C\_1$$,$$C\_2$$组合，找到最高频共现的10个$$C\_L$$出来），bs=16，训了3000个step 线上生效：然后K=2，即只需要batch跑$$761\times 761=579121$$个组合的infer就行了。来一个用户，拿出他的2个cluster的组合，去存储里找到对应的预估的下一个cluster #### 2个LLM [User Feedback Alignment for LLM-powered Exploration in Large-scale Recommendation Systems](https://arxiv.org/pdf/2504.05522) ![](/files/RxxCcukuhmc8gwf0CWU4) 先拿novelty-llm开实验(也可以直接拿线上这路召回的结果)，收集用户对推荐出来的这些类目的正负反馈，然后组织成pointwise或pairwise的语料，训练一个类似reward model的alignment-llm。 ![](/files/mIC3mYrTP6SxW2ctmKj7) 纯离线infer：用novelty llm采用比较高的temperature预测多次，然后用alignment llm打分选挑出topk的cluster，存起来给线上用。 实验对比线上基线的novelty-llm，pointwise和pairwise在多样性、正反馈动作率、完成率均有提升，鈤pointise训练得更快，所以最终推全pointwise ### Google的惊喜度推荐 [推荐算法(2025.6.11)：Google的意外推荐](https://mp.weixin.qq.com/s?__biz=MzkzNDYyNjM1NA==\&mid=2247484786\&idx=1\&sn=1170e694c1f7a2c6759cebf02e0f4945\&scene=21#wechat_redirect) [Serendipitous Recommendation with Multimodal LLM](https://arxiv.org/pdf/2506.08283) 基于[Cluster Anchor Regularization to Alleviate Popularity Bias in Recommender Systems](https://dl.acm.org/doi/pdf/10.1145/3589335.3648312)搞了一个4级的聚类，每个item属于某个树节点，每个节点有对应的自然语言描述。 惊喜度：2个item属于同一个中间节点，但不同的子节点，两个节点可以间隔若干层 拿惊喜度高的样本(一个context item\_id，next item\_id)，即$$(v\_i,n\_j)$$来sft一个MLLM，通过如下方式保证不同cluster的均衡 * 先把$$n\_j$$映射到其cluster $$C(n\_j)$$，得到$$(v\_i, C(n\_j))$$ * 对每个context video $$v\_i$$，聚合$$C(n\_j)$$的满意度，即$$p\_{iC(n\_j)}$$ * 对每个$$C(n\_j)$$，选择$$p\_{iC(n\_j)}$$最高的10个context videos丢到训练数据里去 ![](/files/ZHRjIhAfseMuzNWYteXL) * prompt1、2、3都是直接输出预测的cluster，1和2是单模态(text/video)，3是多模态（text+video） * prompt4是CoT，其实就是让模型先总结出当前视频的cluster，再预测下一个不同的cluster 衡量标准： * match rate：生成的描述是否是合法的cluster * recall：生成的描述和label的描述是不是完全一样 发现： * match rate不同prompt差不多，都能很快收敛到接近99%，而且video+CoT能大大加速这个收敛速度 * video很重要，带上video的比text only要好很多 * video+CoT比video略好 * video+text不如video only，说明这个prompt3还比较粗暴 * 另外还发现帧数越多效果越好，但match rate的收敛速度不受影响 实际推理时用了能cover 80%展现的高热视频，只需要不到12小时就能推理完；后来做了增量更新版本，但因为高热视频变化不多，所以速度也可以接受 ### Google的PLUM [PLUM: Adapting Pre-trained Language Models for Industrial-scale Generative Recommendations](https://arxiv.org/pdf/2510.07784) [「谷歌a」PLUM: Adapting Pre-trained Language Models for Industrial](https://mp.weixin.qq.com/s/2kSjLHfegEvxtwjWCQvOVg) ![](/files/paoCwGAH80F770LZd8Hx) sid生成: * 输入：多个多模态emb，各自过encoder再concat到一起，再映射成一个emb * 多层精细化量化： * 多分辨率码本：码本大小$$2048/2^{{level}-1}$$，即越深层的码表越小 * 渐进式mask：即图中的m，训练的时候随机一个r，然后从1到r的layer保留，后面的layer mask掉 * 共现对比学习正则：一条样本是一个共现pair，在batch内算softmax，$$\mathcal{L}*{\text {con }}=-\sum*{i=1}^{2 N\_b} \frac{\exp \left(\operatorname{sim}\left(p\_i, p\_i^{+}\right)\right)}{\sum\_{j=1}^{2 N\_b} \exp \left(\operatorname{sim}\left(p\_i, p\_j\right)\right)}$$， * 最终loss就是重建Loss+rq\_loss+共现正则 ![](/files/bJlbXiP6uBAkWHP5n8Bs) continue pre-training(CPT) * 一半的样本是用户行为 * 一半的样本是video metadata * 训练200w个step，bs=16，总共260B的token，基于预训练好的LLM(900m in 4B的moe)进行CPT，发现CPT后的模型对于自然语言和sid的混合输入仍然有很好的in-context learning能力 ![](/files/MVV64cW76EbT7VV77UOC) sft如图，输入有文本也有sid，预测下一个sid。设计了带reward（人工为每个点击拍的）的loss：$$\mathcal{L}*{\mathrm{SFT}}=-\sum*{t=1}^L r\left(\text { user, } v\_{c l i c k}\right) \cdot \log P\left(\text { sid }*t \mid \text { Context }*{\text {user }}, \text { History }*{\text {user }}, \text { sid }*{\，有jax和pytorch版本 基于PLUM做constrained decode加速 ![](/files/2slyuxokYf86WTbHGMDT) 假设3级sid，每一级有3个token * a：限制了只能在3个item里decode，分别是item1=(A1,B2,C1), item2=(A3,B1,C2), item3=(A3,B1,C3) * b：在CPU上构建Trie树 * c：full transitioin matrix：左边是一个node，包括root+每一条中间路径，右边的是这个node对应的孩子节点，编号为1\~7 * d：CSR(compressed sparse row)矩阵：第三行是c右边的1\~7，第二行是第三行每个节点对应的tokenid，第一行是第二行每一个node的start下标 * e：以node 4为例，从d中可以看到只有C2和C3是valid的，就把C1给mask了（详见算法1和算法2，应该是算完所有token的logprob后做的mask） ![](/files/jGKT2XGHD0JQWoYEEcMH) ![](/files/C6kFnY8Uz2gzqO9vuQV3) ### Meta的AdLlama [Improving Generative Ad Text on Facebook using Reinforcement Learning](https://arxiv.org/pdf/2507.21983) 采用强化学习结合表现反馈（RLPF），以广告表现数据作为奖励信号精调Llama模型，生成更高点击率的广告文案 ### Meta的Generative Reasoning Re-ranker [Generative Reasoning Re-ranker](https://arxiv.org/pdf/2602.07774) ### 美团的MSD [Balancing Efficiency and Effectiveness: An LLM-Infused Approach for Optimized CTR Prediction](https://arxiv.org/pdf/2412.06860) 通过大模型知识蒸馏，将LLM融入点击率预测模块 ### 美团的CoEA [When Relevance Meets Novelty: Dual-Stable Periodic Optimization for Exploratory Recommendation](https://arxiv.org/pdf/2508.00450) 设计了profile llm、novelty llm、relevance llm完成类目预估任务，并进行周期性的sft ![](/files/OerzIxBGyKivvFKmVAT9) 1. 用户长期行为经过多层transformer产出user emb，并通过rq-vae得到sid 2. 每个sid里采样一些用户，把他们的点击历史丢给profile LLM（不微调），总结出用户画像 3. 用户短期行为的类目list(2个)+上面产出的用户画像，丢给novelty LLM（基于qwen2.5-7b-instruct-1M），预估1个类目(应该是要跑多次吧，或者prompt写错了) 4. 上面的3个类目+用户画像丢给relevance LLM（基于qwen2.5-7b-instruct-1M），输出相关性得分 ![](/files/CzKCFXhkWlaWDYFlV7eS) 实现细节： * key=sid+近期类目，value=相关性得分最高的若干个类目，存到离线存储里，在线直接查，加一路召回 * sft novelty LLM：给定历史类目预估下一个类目 * sft relevance LLM：当成RM，用户点的是正例，从曝光未点击里随机出负例 * 周期性地微调：收集用户反馈，固定relevance LLM，用dpo（RM打分高的vs打分低的）来finetune novelty LLM，同时加kl让模型不要离上一轮的太远 ### 美团的DMGIN [DMGIN: How Multimodal LLMs Enhance Large Recommendation Models for Lifelong User Post-click Behaviors](https://arxiv.org/pdf/2508.21801) ### 美团的UserLM-R1 [UserLM-R1: Modeling Human Reasoning in User Language Models with Multi-Reward Reinforcement Learning](https://arxiv.org/pdf/2601.09215) ![](/files/P5uvwJlxbppVWy2fwkYW) * Step 1：通用用户画像构建 * 静态画像：背景信息、人格特质、表达风格、生活场景。基于AlignX（[From 1,000,000 Users to Every User: Scaling Up Personalized Preference for User-level Alignment](https://arxiv.org/pdf/2503.15463)）的数据集，把其中如下图的90维偏好向量和人口属性特征丢给LLM，通过不同prompt产出上述4种静态画像 ![](/files/6yWAnQKDZJkLn8Srj9b1) ![](/files/jLMqGvYQTYKJpR4BXvsv) * 动态画像：场景记忆、核心诉求、决策策略、状态转移(如信任感、情绪变化)。基于[VoiceAgentEval: A Dual-Dimensional Benchmark for Expert-Level Intelligent Voice-Agent Evaluation of Xbench’s Professional-Aligned Series](https://arxiv.org/pdf/2510.21244)的SOP相关prompt进行修改，把用户相关的信息删了，SOP任务数从30个扩展到了450个。在用户与agent对话时，动态地调用LLM产出上述4种动态画像 * Step 2：目标驱动的decision-making策略 * t-1时刻：输入prompt+静态profile+动态profile+历史对话，UserLLM输出CoT+新的动态profile+用户回答 * t时刻：把产出的新的动态profile替换掉t-1的动态profile，用户回答加入历史对话中，其他不变 * Step 3：SFT：就是拿上面的语料来sft user llm * Step 4：多奖励强化学习优化 * 规则reward：输出格式、动态画像里的要点匹配等 * Rubric reward：LLM judge产出4种类型奖励： * 回应一致性奖励（response consistency reward）：评估回复与角色画像的契合度、风格连贯性及口语自然度，确保生成的对话真实类人，且严格贴合目标角色设定。 * 推理质量奖励（reasoning quality reward）：通过惩罚模板化冗余内容，综合评估目标管理精度、状态转换有效性及推理深度，进而培养严谨的多步骤策略推理能力。 * 对齐度奖励（alignment reward）：考核对思维链（chain of thought）中制定的核心策略的忠实执行程度。 * 策略能力奖励（strategic capability reward）：激励模型准确识别对话陷阱、实现状态对齐，且关键在于通过逻辑反击主动掌握对话主动权，使模型能够稳健应对具有欺骗性的场景。 ### 阿里的BEQUE [LLM落地淘宝电商搜索场景，显著提升长尾query改写效果](https://mp.weixin.qq.com/s/GmogjAHt0Hrwd8RmtOqS7A) [Large Language Model based Long-tail Query Rewriting in Taobao Search](https://arxiv.org/pdf/2311.03758) WWW24 ![](/files/lHYJzE2luB1dCJ5MKUon) * multi-instructions的sft：基于在线日志，通过拒绝采样得到multi-instrunctions的SFT数据集，任务是重写query，还混合了质量分类、query改正、CoT任务 其中的3个task如下： | Task | Prompt Example | | ---------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Quality Classification |

Is this a good e-commerce query rewrite?
Query: {query}
Rewrite: {rewrite}
System: {Yes or No}

| | Title Prediction |

Please generate product titles that match input query
Query: {query}
System: {product title}

| | Chain of Thought |

Your task is to rewrite the input query into a query that makes it easier to search for related products, and you are required to give the thought process and then the query rewriting result. The thought process and the query rewriting result are separated by a semicolon.
Query: {query}
System: {CoT}; {Rewrite}

| * offline feedback：用训好的LLM生成多个候选rewrites，构建了一个离线的淘宝系统，对这些候选rewrites进行搜索得到结果，并用结果的quality scores来对候选rewrites进行排序 * objective alignment：基于候选的rewrites的排序，使用PRO方法（[Preference ranking optimization for human alignment](https://arxiv.org/pdf/2306.17492)）来逼近这个排序。 给定顺序$$y\_1>y\_2$$，preference probability如下，其中$$r(\cdot)$$是reward函数： $$ P\_{B T}=\frac{\exp \left(r\left(y\_1, x\right)\right)}{\exp \left(r\left(y\_1, x\right)\right)+\exp \left(r\left(y\_2, x\right)\right)} $$ 对应的PRO loss如下，$$\mathcal{T}\_k^i=1 /\left(r\left(y\_k\right)-r\left(y\_i\right)\right)$$，$$\mathcal{T}\_k^k=\min \_{i>k}\left(\mathcal{T}\_k^i\right)$$： $$ \mathcal{L}*{P R O}(\theta)=-\mathrm{E}*{(x, y) \sim \mathcal{D}*{P R O}} \sum*{k=1}^{n-1} \log \frac{\exp \left(\frac{\pi\_{P R O}\left(y\_k \mid x ; \theta\right)}{\mathcal{T}*k^k}\right)}{\sum*{i=k}^n \exp \left(\frac{\pi\_{P R O}\left(y\_i \mid x ; \theta\right)}{\mathcal{T}\_k^i}\right)} $$ 应用：离线刷库，实验的gmv、单量都有收益，长尾query效果更好 ### 阿里的BAHE [SIGIR'24 | 打破长度障碍：LLM增强的长文本用户行为CTR预测](https://mp.weixin.qq.com/s/h0p1QrapTGxOonccxNVNuQ) [Breaking the Length Barrier: LLM-Enhanced CTR Prediction in Long Textual User Behaviors](https://arxiv.org/pdf/2403.19347) ![](/files/fnrvL9jfApgEPGeiYR1T) * 防止由于重复编码相同用户行为而产生的计算冗余：利用LLMs的预训练浅层提取来自用户序列的最细粒度的原子用户行为(例如购买星巴克、订酒店)的emb，并将它们存储在离线数据库中 * 从db里查出来，和item一起过LLMs的更深层可训练层 ### 阿里的LUM [Unlocking Scaling Law in Industrial Recommendation Systems with a Three-step Paradigm based Large User Model](https://arxiv.org/pdf/2502.08309) ![](/files/Y5xz2o1s4hXdkdC6Jd6b) 将LLM用到推荐系统里的3个步骤： * 知识构建：拿用户行为序列(condition token+item token)预训练一个LUM * 知识查询：输入用户行为序列+query(构造的condition token)，得到answer(用户在这个condition下可能感兴趣的item token) * 知识应用：把上一步得到的结果当成一个特征，加入精排模型里 ![](/files/lucEFjQiha91M99InXcl) * c预估下一个i，c和i没有label，c+i+c预测再下一个i。所以最后输入的是一个c，这样就可以预测下一个i了 * 这里的condition token有比较多的可能性，例如场景、搜索query、类目等 * 不同condition预测出多个next token，然后和target token算相似度，再输入给后面的精排 ![](/files/6NELVA7NuzwOkIgR5Lde) 在线infer的加速，u的历史是可以共享的，所以同时把多个c输入进来，然后通过mask（感觉可以参考mtgr的mtp）就可以实现u侧历史只算一次 ### 阿里的SERAL [Bursting Filter Bubble: Enhancing Serendipity Recommendations with Aligned Large Language Models](https://arxiv.org/pdf/2502.13539) ![](/files/IxzW841F7qwsyVMw0x5E) ### 阿里的URM [当购物用上大模型！阿里妈妈首发世界知识大模型，破解两大推荐难题](https://mp.weixin.qq.com/s/eJewql0mZk199HyzkjkiuA) [Large Language Model as Universal Retriever in Industrial-Scale Recommender System](https://arxiv.org/pdf/2502.03041) ![](/files/c75iZXaGHl2P6yETKQc5) 2个特殊token： * `[UM]`对应的输出通过用户建模头$$h\_{UM}$$映射到用户表示空间，用于候选商品的生成。如图，每个item对应一个`[UM]`； * `[LM]`及其后续符号对应的输出通过语言模型头$$h\_{LM}$$映射到文本空间，用于文本token的生成。 ![](/files/XUcCKPU0GsbowG2xHu7c) item emb的获取： * 融合id emb，文本emb和图像emb * 底层的文本encoder和图像encoder freeze，上层的mlp可训练 * sft训练（应该就是下面那个模型） Sequence-In-Set-Out：其实就是把`[UM]`的输出拆成H个，每个去和item向量算相似度，再merge到u和i的相似度 最终sft的时候计算UM的loss和LM的loss，即图中的item和文本的loss ![](/files/EhA1Vq5y9hEyNfJ77K8t) ### 阿里的RecGPT [RecGPT Technical Report](https://www.arxiv.org/pdf/2507.22879) [搜广推工业界论文每日速递-20250731-阿里RecGPT: 淘宝首猜全量上线](https://mp.weixin.qq.com/s/hrxoPwbw8OErX3XompmAZQ) ![](/files/eYnjXI8X7wUK7MgfcTLB) 4步： * 用户兴趣挖掘：输入用户人口属性和历史序列，总结出用户的兴趣(从给定的兴趣集合里选出match的，并给出原因)。用TBStars-MoE-42B-A3.5B进行sft。 * item tag预测：输入用户人口属性和历史序列，加上总结的用户兴趣，输出用户可能感兴趣的50个item tag（看着是一个形容词+名词的短语），及对应原因。用TBStars-MoE-42B-A3.5B进行sft。 * item检索：user-tag-item 3塔模型，拿正常推荐行为训练，最终logit融合了tag-user和user-item的logit * 推荐理由生成：输入user兴趣、item信息，输出推荐理由。用Qwen3-14B进行sft。用一个pretrain好的模型把item tag映射到类目，而每个类目下有一些item，最终离线产出一个离线词表，每个tag只要存它对应的那个tag下的item的理由就行了。 ![](/files/OaerYRO0OhkM1jielyBJ) 左边大概就是对一个用户的行为进行压缩，即 * item压缩：每个item只保留必要信息，例如name/cate/brand等 * 序列压缩：先按时间窗口聚合，再按item（感觉应该是类目粒度吧）频次倒排聚合 右边是3阶段的训练 * 基于课程学习的多任务finetune：简单->中等->复杂，搞了16.3k的样本，让模型学习电商知识 * reasoning-enhanced pre-alignment：用deepseek-r1产出了用户兴趣挖掘的90k推理数据，并通过人工筛选出19k高质量数据进行蒸馏。 * self-training evolution：模型自己生成数据，并结合人工和llm-as-a-judge进行迭代优化，共21.1k高质量数据，如下图 ![](/files/oFV4hU4aj8IDU2AWtb0u) ![](/files/bbBC8qm77613tGELSsJx) item tag预测也包括两阶段： * alignment：就是用户兴趣挖掘的后两步，只是换了一下筛选数据的标准 * 增量学习：双周更新一次，拿最近14天的数据，用QwQ-32B产出数据，并考虑类目间的数据量平衡(每个类目的数据量差不多) ![](/files/X7igjQnf0fcRxVXKF9j1) user/item都是正常的推荐模型，有id特征、序列特征等，tag塔就是预测出的item tag（前面提到了tag可以映射到类目，所以这里就是item对应的tag）切词后丢进去，3个loss： * u-i的推荐行为loss * tag和i之间的loss，正样本是点击item的tag，负样本是随机一个item的tag * 类目对比学习loss，同类目的tag是正样本，不同类目的tag是负的 ![](/files/wmleEuvuKr2cNpiDzJqB) * alignment：同上，改了筛选标准 * 离线生产：如上所述，产出interest-item-理由离线表 ### 阿里的SaviorRec [SaviorRec: Semantic-Behavior Alignment for Cold-Start Recommendation](https://arxiv.org/pdf/2508.01375) 利用大型预训练多模态模型（如LLaMA、ViT、CLIP）生成语义表示，并与用户行为空间对齐，提升冷启动和长尾物品推荐性能。 ### 阿里的ChoirRec [ChoirRec: Semantic User Grouping via LLMs for Conversion Rate Prediction of Low-Activity Users](https://arxiv.org/pdf/2510.09393) ![](/files/schQs62edp8MKuAbFIaJ) * stage1：Hierarchical Semantic User Group Generation * Semantic Profile Synthesis via LLM：输入用户静态信息、各种时间窗口的行为类目序列、搜索序列，输出core identity、interest points和consumption philosophy * Hierarchical Group Construction： * 通过Qwen3-embedding-8B等模型将profile编码成emb， * 通过RQ–KMeans搞出M级semantic group id * stage2：构建Group-aware Hierarchical Representation * Hierarchical Group ID Fusion：右图，M级group id对应的emb按顺序融合，再concat过mlp * Group Attribute Completion：当前group里用户的静态特征+统计特征聚合起来，相当于对低活用户可以有一个group级的初始化；可以预先算好 * Group Behavioral Sequence Construction： * Group Interest Identification：group内所有用户的购买历史里，聚合出top-k的类目 * Group Sequence Construction：top-k类目中，保留每个类目里的头部item，同时用group内的平均购买时间来排序 ![](/files/wr2PNS7QZUdsZmHlrev3) * stage3：Group-aware Multi-granularity(多粒度) Module * individual channel：作为teacher，U和I过tower * group channel：作为student，G和I过mlp过tower * group channel的输入通过fusion tower输入给individual channel，但对group channel有stop grad * 用户活跃度特征过nn得到一个emb，然后输出2个gate： * merge用：两个channel的logit进行merge的时候用上面的gate加权，$$z\_{\text {fused }}=\left(1-\alpha\_{\text {fusion }}\right) \cdot z\_{\text {ind }}+\alpha\_{\text {fusion }} \cdot z\_{\text {group }}$$ * 蒸馏用：mse加上一个margin，另外有一个置信度的gate（用户购买数大于某阈值\&teacher输出过完sigmloid比0.5大一定阈值）$$g\_{\text {qual }}=\mathbb{I}\left(\left|S\_u^{\text {buy }}\right| \geq \theta\_{\text {act }} \wedge\left|\sigma\left(z\_{\text {ind }}\right)-0.5\right|>\theta\_{\text {conf }}\right)$$，还有上面的gate，$$\mathcal{L}*{\mathrm{KD}}=g*{\text {qual }} \cdot \alpha\_{\text {distill }} \cdot \mathcal{L}\_{\text {margin }}$$ ![](/files/8sTzPhMASbH9J4MeQJpE) ### 阿里的CoAST [Cognitive-Aligned Spatio-Temporal Large Language Models For Next Point-of-Interest Prediction](https://arxiv.org/pdf/2510.14702) ![](/files/I2X97pHg4vGaeCsERxCV) sid每级code book的每个code搞一个special token(代码应该是`tokenizer.add_tokens([...])`)，location也类似地搞一下，用CPT让LLM学到sid的知识，然后预测下一个sid ![](/files/XbRIsV8y1gYf9tUhJezi) ### 阿里的CoCo [Synergistic Integration and Discrepancy Resolution of Contextualized Knowledge for Personalized Recommendation](https://arxiv.org/pdf/2510.14257) 通过动态构建用户特定上下文知识嵌入、自适应知识融合和矛盾解决模块，实现语义与行为潜在空间的深度整合。该方法端到端训练，支持任意推荐骨干网络的工业部署。 ### 阿里的LLM-I2I [LLM-I2I: Boost Your Small Item2Item Recommendation Model with Large Language Model](https://arxiv.org/abs/2512.21595) 训2个llm： * generator：输入u，预估下一个item id（工业界数据集这个空间很大吧？不知道咋处理的，论文里好像没提），对长尾item有加权 * discriminator：输入u+i，预测yes/no 拿generator产出一堆数据，再拿discriminator过滤一下，保留高质量数据，加到训练样本里，然后训一个正常的i2i模型 ### 阿里的SIGMA [SIGMA: A Semantic-Grounded Instruction-Driven Generative Multi-Task Recommender at AliExpress](https://arxiv.org/pdf/2602.22913v1) ![](/files/BRA6qzsJCeE8fL6tJeAU) #### Multi-view Semantic Grounding 从4个角度找正负样本 * 语义对齐：搜索的query和item的点击共现行为 * 视觉对齐：多模态相似度 * 知识对齐：感觉就是一些业务知识，例如他们的在线系统能把节日、热点话题、季节变化这类世界知识，和平台内对应的主题商品关联起来 * 协同对齐：同互动session里的高频共现item对 两个loss：正负样本间的对比学习，llm（可训练）和pretrained item emb（freeze）间的蒸馏 #### Hybrid Item Tokenization * 把llm产出的emb用RQ-VAE搞成多级sid * 每个item加了一个unique id token：不是直接加到tokenizer里，可以理解为`[emb]`这种token，然后外挂了一个kv存储，把pretrained id emb（id/text/img各一个）拿过来，并merge #### Multi-task Supervised Fine-tuning * 通用推荐：正常的推荐 * 受限推荐：例如约束了query/类目等 * 探索推荐：长尾item+用户兴趣探索 * common sense推荐：符合季节性、节假日主题的推荐 要预估的有2部分 * 下一个sid：用正常的ntp loss * 下一个item id：用special token `q`表示，用InfoNCE #### Three-step Item Generation * beam search出K个sid，同时保留对应的beam score(多级sid的score连乘) $$\phi$$ * 把q这个特殊token加进来再过llm得到输出，拿来去ann找出M个item * 然后按如下公式排序 $$ P\left(v\_i \mid \mathcal{T}\right)=P\left(c\_1^k, \ldots, c\_{\ell}^k \mid \mathcal{T}\right) \times P\left(i d\_i \mid \mathcal{T}, c\_1^k, \ldots, c\_{\ell}^k\right) $$ 第一项是sid的beam score，第二项如下，其中的$$\sigma$$是前k个beam score的标准差，对于有约束的任务，要求相关性高，一般标准差较大，对于要求多样性的任务，则标准差小 $$ P\left(i d\_i \mid \mathcal{T}, c\_1^k, \ldots, c\_{\ell}^k\right)=\frac{e^{\cos \left(\boldsymbol{h}\_k, \tilde{\boldsymbol{v}}*i\right) \cdot \sigma\left(\left{\phi\_1, \ldots, \phi\_K\right}\right) / \tau}}{\sum*{v\_j \in \mathcal{V}\_k} e^{\cos \left(\boldsymbol{h}\_k, \tilde{\boldsymbol{v}}\_j\right) \cdot \sigma\left(\left{\phi\_1, \ldots, \phi\_K\right}\right) / \tau}} $$ ![](/files/ZZ7XRzxqjko3Xh9uyxPT) 实验的时候是加了一路近线召回 ### 快手的LSVCR [Enhancing Sequential Recommender with Large Language Models for Joint Video and Comment Recommendation](https://arxiv.org/pdf/2403.13574) Recsys25 用于联合视频和评论推荐，仅在训练中使用LLM增强语义。 ### 快手的LEARN [快手广告领域的大模型技术探索与实践](https://mp.weixin.qq.com/s/9VmOb3q4enWhqqJ_f7jnFA) [Knowledge Adaptation from Large Language Model to Recommendation for Practical Industrial Application](https://arxiv.org/pdf/2405.03988) 过往的llm+推荐的两种思路： * freeze LLM参数并适应推荐领域数据：将用户行为历史改写成文本prompt，直接丢给LLM生成top-k推荐结果，例如： * [Chat-rec: Towards interactive and explainable llms-augmented recommender system](https://arxiv.org/pdf/2303.14524) * [Large Language Models are Zero-Shot Rankers for Recommender Systems](https://arxiv.org/pdf/2305.08845v2) * [Is ChatGPT a Good Recommender? A Preliminary Study](https://arxiv.org/pdf/2304.10149) * [LLM-Rec: Personalized Recommendation via Prompting Large Language Models](https://arxiv.org/pdf/2307.15780) * [Large Language Models are Competitive Near Cold-start Recommenders for Language- and Item-based Preferences](https://arxiv.org/pdf/2307.14225) * [Is ChatGPT Fair for Recommendation? Evaluating Fairness in Large Language Model Recommendation](https://arxiv.org/pdf/2305.07609) * 在推荐领域的特定文本数据集上微调LLM：利用LLM捕捉用户行为序列，通过设计提示prompt，使LLM学习用户和物品之间的潜在关系，在预测任务中理解用户的偏好变化和行为模式，从而更好地预测用户可能感兴趣的物品，例如： * [A Bi-Step Grounding Paradigm for Large Language Models in Recommendation Systems](https://arxiv.org/pdf/2308.08434) * [Tallrec: An effective and efficient tuning framework to align large language model with recommendation](https://arxiv.org/pdf/2305.00447) * [Llara: Aligning large language models with sequential recommenders](https://arxiv.org/pdf/2312.02445) * [ReLLa: Retrieval-enhanced Large Language Models for Lifelong Sequential Behavior Comprehension in Recommendation](https://arxiv.org/pdf/2308.11131) * [Where to Go Next for Recommender Systems? ID- vs. Modality-based Recommender Models Revisited](https://arxiv.org/abs/2303.13835) 上面两种方法可以看成是Rec-to-LLM，即将推荐这个target domain适配到LLM这个source domain上去，有如下缺点： * 将用户历史全丢给LLM不现实：一方面开源的LLM目前只支持1k(baichuan)-4k(llama)，不支持这么长的序列，另一方面复杂度和序列长度呈二次关系 * 微调的方案可能会出现灾难性遗忘(catastrophic forgetting)：全参数微调，会让模型**丢失在预训练过程中学到的开放世界的知识**，而LoRA的效果也不好。原因： * domain gap：两个领域有巨大的差别(profound gap)，[Continual Learning of Large Language Models: A Comprehensive Survey](https://arxiv.org/pdf/2404.16789)发现了全量参数微调会导致LLM对原有知识domain的严重的灾难性遗忘。 * 训练目标不对齐（misalignment）：LLM是next token prediction，学习大语料的general知识；finetune则主要是检索类的任务，强依赖用户-item的交互行为 其实有rec-to-llm和llm-to-rec两类想法 ![rec2llm-llm2rec](/files/oHKOFLGXKLV9ePbJmJiZ) 快手商业化把llm用到推荐的思路变化： ![](/files/OYy2DsMBT22IMfg9jOed) 本文提出了LEARN(Llm-driven knowlEdge Adaptive RecommeNdation)，实现了LLM-to-Rec，让LLM作为content extractor，推荐任务是训练目标。 ![learn-cex-pal](/files/nngQCREJK1D2eSL9HMUY) * Content EXtraction(CEX)：输入item描述，过预训练的LLM（参数freeze）得到的每个token的输出pooling得到item的emb $$E^c$$ * Preference ALignment(PAL)：把$$H$$个$$E^c$$输入一个content adapter(就是一个MLP)，然后过12层的可训练的transformer得到$$H$$个输出emb，最后再过一个online projection(也是一个MLP)降维到64，得到$$E^{user}$$ ![learn](/files/rwYnSACBfKzxHWuVlV8Q) 假设用户点击了H+T个item，拆成1~~H和H+1~~H+T这两部分， * user tower：1\~H的item输入CEX+PAL，得到H个输出 * item tower：有3个，结构都是输入H+1\~H+T的item，网络参数和user tower共享；infer时只输入一个item * item tower a：经过CEX得到$$E^c$$，再经过PAL得到$$E^{item}$$，和user tower一样用causal attention * item tower b：经过CEX得到$$E^c$$，再经过PAL得到$$E^{item}$$，使用self-attention，每个item只关注自己 * item tower c：只经过CEX，直接得到$$E^{item}$$ 消融后发现item tower a效果最好，所以用了a loss用的是pinnerformer的dense all action loss（[PinnerFormer: Sequence Modeling for User Representation at Pinterest](https://arxiv.org/pdf/2205.04507)），即从`1~H`里随机挑m个出来，每一个去预估`H+1~H+T`里的随机一个正样本 ![](/files/qSQ1Wvi20Os9Dhy1xN3Z) 在线使用时如下图，其中user emb和item emb就是两个tower的输出，会先concat并过个小fusion module得到fusion emb，然后一方面过个mlp算个cvr loss，另一方面和user emb、item emb还有其他特征concat再送给后面的模块正常算ranking loss ![](/files/vLSpRouZHNWaKL424MSM) ### 快手的LARM [LLM-Alignment Live-Streaming Recommendation](https://arxiv.org/pdf/2504.05217) ![](/files/Rj1Ky6n4o4S9uS19zZJn) 结合直播的特点：同一个直播间在不同时间段的内容不同，不同用户由于进房时间不同，看到同一个直播间的内容也不同。 整体思路还是比较简单的 * 输入直播间和主播的基础信息，拿100B的llm标出来一些数据（生成如下的问答pair对、以及对直播内容的总结与理解），去finetune一个7B的llm * 用这个7B LLM产出emb（pooling）结合主播侧特征通过gating融合得到直播间emb，和user去双塔inbatch softmax * 【这一步的时效性比较高，每30秒更新一次】拿上面融合过的emb，通过rq-vae进行聚类，把对应的code扔给线上推荐模型 qa类prompt： ```shell Live-streaming information: #time, #images, #speeches, #comments, #author_information; You need to pay attention to the fact that the person in the live-streaming may not be the author himself, but someone else. Please generate ten instruction questions as diverse as possible based on the provided live-streaming information. These questions are about facts or an understanding and evaluation of relevant content. Do not ask any questions that cannot be answered confidently. Finally, you need to return the result in the following form: 1. {"Question":..., "Answer":...} 2. {"Question":..., "Answer":...} ``` 总结类prompt： ```shell Live-streaming information: #time, #images, #speeches, #comments, #author_information; You need to pay attention to the fact that the person in the live-streaming may not be the author himself, but someone else. Complete the following tasks: 1. Describe the current events and content in the live broadcast room in detail in one paragraph, including but not limited to: Content: including detailed visual information, such as whether there is text, the look and feel of the picture, the tone, etc. + other_tasks, Finally, you need to return the result in the form of json: { "Event and content": { "Content": ..., "Character": ..., "Scene": ..., "Event": ..., "Atmosphere": ..., "Highlights": ..., "Target user group": ... },} ``` 实验部分列了两个主场景的收益，但没有说实验流量 ### 快手的LCU WWW Companion 25，[Comment Staytime Prediction with LLM-enhanced Comment Understanding](https://arxiv.org/pdf/2504.01602) ![](/files/UeH1nHWo09Aq0nuKWOkz) 用户在一个视频上的的staytime=视频观看时长+评论区时长 用户在评论区的staytime和如下几个因素的关系（后面两个和本文关系不大）： * top评论的平均点赞数：点赞数越多，评论区的staytime越短，说明在比较不成熟的评论区，用户需要滑动更多来找到他们喜欢的评论，反之用户则更容易在头部评论里找到喜欢的 * 评论的用户互动数（点赞/回复）：互动数越多，评论区的staytime越长，说明用户更有沉浸感 * 视频物理时长：物理时长更长的视频，评论区的staytime更长 * 视频观看时长：视频观看时长更长的视频，评论区的staytime更长，且在1000到1200s处有一个突增 ![](/files/HTnlXWgsJIgopypGQpiC) 两阶段： * 训练LLM：基于如下3个任务sft一个LLM * staytime分桶预估：给定用户历史行为，预估用户在评论区的staytime * top评论预估：给定一些评论，预估哪个评论的互动数最高 * 用户-评论互动预估：给定一些评论，基于用户历史行为预估用户最有可能对哪些评论互动 * LLM集成到推荐系统中并增加辅助loss * 用户无关的评论排序：给定评论list，给出评论热度的排序 * 用户相关的评论排序：给定用户+评论list，预估用户对哪些评论会有互动 ### 快手的KuaiMod [KuaiMod来了！快手用大模型重构短视频生态格局](https://mp.weixin.qq.com/s/HO7I_9E1iwteSRHLukz81A) [VLM as Policy: Common-Law Content Moderation Framework for Short Video Platform](https://arxiv.org/pdf/2504.14904v1) * 首个短视频平台劣质内容判别基准测试：面向快手生态构建了短视频劣质内容分类体系，形式化定义了短视频内容判别任务，并基于真实场景中的用户反馈构建了首个短视频劣质内容判别基准测试。KuaiMod劣质内容分类体系包含4种主要的劣质类别以及15种细粒度劣质类别。基准测试包含1000条短视频样本，涵盖 15种细粒度劣质类别，完全由人工标注，并经过多轮数据清洗以保证正确性。 * 首个工业级自动化内容判别解决方案：KuaiMod是首个在工业场景下验证了部署价值的自动化内容质量判别解决方案，在快手平台多个场景下的部署结果表明，KuaiMod方案具有能够与人工判别相媲美的准确率。 * 基于用户反馈的强化学习训练+更新策略：区别于静态的规则或内容判别API，基于判例的劣质内容建模使得KuaiMod可以通过迭代训练数据完成判别策略的更新。为了保证实时性和准确率，我们设计了基于用户反馈的强化学习范式，利用用户的线上反馈构造新的训练数据，实现线上判别服务的天级更新。 ### 快手的R4ec [RecSys'25|快手R4ec：用 “反思” 让推荐更懂你](https://mp.weixin.qq.com/s/zYkZE8fqARBfywWFeJwiNQ?scene=1) [R4ec: A Reasoning, Reflection, and Refinement Framework for Recommendation Systems](https://arxiv.org/pdf/2507.17249) ![](/files/AYuh3JXXOA7JOpKEUOCX) 目前有`(hist, item, label)`，label可以是正样本或者负样本 * 输入(hist,item)，问模型用户会不会喜欢这个item(pred)，并总结用户偏好(reasoning) * 输入(hist,item,reasoning)，问模型这个用户偏好是否合理（judge），并反思出不合理的原因（reflect） * 如果judge == 合理 and pred == label： * `[(hist),(reasoning)]`加到**reasoning数据集**里 * `[(hist,reasoning), (judge, reflect="")]`加到**reflect数据集**里 * 如果judge == 不合理 and pred != label： * 输入hist,item,reasoning,reflect，让模型输出用户会不会喜欢这个item(pred')和refine后的用户偏好(reasoning\_r) * 如果pred' == label： * `[(hist,reasoning), (judge, reflect)]`加到**reflect数据集**里 * `[(hist,reasoning,reflect),(reasoning_r)]`加到**refine数据集**里 * else：扔掉`(hist, item, label)` item侧也复用了类似的流程，把输入的(hist, item)改成(item, pos, neg)，pos是对这个item给过正反馈的user历史行为，neg类似，产出了对应的item的reasoning数据集、reflect数据集、refine数据集 ![](/files/ghJPESEZjnrLzWZGQTCK) 训练：用lora训练2个模型 * actor模型：用reasoning数据集和refine数据集训练 * reflection模型：用reflect数据集训练 发现actor模型7b就够了，但reflection模型从0.5b到72b效果会一直涨 推理： * 迭代优化：通过actor产出知识(即reasoning)，然后让reflection模型给出reflect，再refine，直到产出靠谱知识 * 过滤：actor并行产出多个知识，reflection模型过滤掉很不靠谱的，剩下的知识对应的向量取平均 在线使用：通过actor生成user和item的知识，然后用bge-m3产出向量给推荐模型用 ### 快手的DAS [CIKM'25|快手 DAS：让广告推荐更懂4亿用户](https://mp.weixin.qq.com/s/76ephhal3AuKROSHCOcAjg) [DAS: Dual-Aligned Semantic IDs Empowered Industrial Recommender System](https://arxiv.org/pdf/2508.10584) ![](/files/EvkDRbtgicbA37GCxHxm) ### 快手的TrackRec [TrackRec: Iterative Alternating Feedback with Chain-of-Thought via Preference Alignment for Recommendation](https://arxiv.org/abs/2508.15388) ### 快手的OneRec-Think [OneRec-Think: In-Text Reasoning for Generative Recommendation](https://arxiv.org/abs/2510.11639) 参考代码： ```python def get_special_tokens(max_range: int = 256) -> list[str]: special_tokens: list[str] = [] special_tokens.append("<|sid_begin|>") special_tokens.append("<|sid_end|>") for prefix in ["s_a", "s_b", "s_c", "s_d"]: for idx in range(max_range): special_tokens.append(f"<{prefix}_{idx}>") return special_tokens def round_up_to_multiple(value: int, multiple: int) -> int: if multiple <= 0: raise ValueError("multiple must be a positive integer") return ((value + multiple - 1) // multiple) * multiple def run(): tokenizer = AutoTokenizer.from_pretrained(base_model_dir) new_tokens = get_special_tokens(max_range=256) print(f"Preparing to add {len(new_tokens)} special tokens.") tokens_added = tokenizer.add_special_tokens( {"additional_special_tokens": new_tokens}, replace_additional_special_tokens=False ) print(f"Successfully added {tokens_added} tokens.") updated_vocab_size = len(tokenizer) target_vocab_size = round_up_to_multiple(updated_vocab_size, 256) print( f"Current vocab size: {updated_vocab_size}, adjusting to: {target_vocab_size} (nearest 256 multiple)." ) model.resize_token_embeddings(target_vocab_size) config.vocab_size = target_vocab_size ``` ### 快手的OpenOneRec [OpenOneRec Technical Report](https://arxiv.org/pdf/2512.24762) ； 数据集： ### 快手的Align3GR [Align3GR: Unified Multi-Level Alignment for LLM-based Generative Recommendation](https://arxiv.org/pdf/2511.11255) ![](/files/qxP2tnMxoCPfHcEFLr33) ![](/files/Wn244M3lwEIde14F3Vqs) ![](/files/ngHP9l1MDohFCnPiLVKP) 基于llama2-7b ### 字节的HLLM-Creator [HLLM: Enhancing Sequential Recommendations via Hierarchical Large Language Models for Item and User Modeling](https://arxiv.org/abs/2409.12740) [HLLM-Creator: Hierarchical LLM-based Personalized Creative Generation](https://arxiv.org/abs/2508.18118) ### 腾讯的LEADRE [LEADRE: Multi-Faceted Knowledge Enhanced LLM Empowered Display Advertisement Recommender System](https://arxiv.org/pdf/2411.13789) ### 微信的PRECISE Recsys24 [微信PRECISE:多场景落地基于协同信号和语义信息的生成式序列推荐](https://mp.weixin.qq.com/s/pld010curqUv_NsqdvSEDA) [PRECISE: Pre-training Sequential Recommenders with Collaborative and Semantic Information](https://arxiv.org/pdf/2412.06308) ### Spotify的LLM Preview生成 [Transforming Podcast Preview Generation: From Expert Models to LLM-Based Systems](https://arxiv.org/pdf/2505.23908) [推荐算法(2025.6.3)：Spotify的LLM应用，效果明显](https://mp.weixin.qq.com/s/2SJ5IdXa5Hmygx8VxGlDcQ) ### Spotify的GLIDE [Deploying Semantic ID-based Generative Retrieval for Large-Scale Podcast Discovery at Spotify](https://arxiv.org/pdf/2603.17540) ![](/files/Dfv71ay3842HWCrPGQ7J) * semantic grounding：双向翻译任务：SID -> 文本描述和文本描述 -> SID。训练上他们分两阶段：先冻住trans backbone，只训新增SID embedding；再冻结所有参数（包括emb），用LoRA去适配backbone。这个设计是为了尽量保住原始语言能力，避免灾难性遗忘。 * instruction tuning：用户的协同emb通过soft token的方式引入，加上近期sid和一些文本特征构成prompt，再加上一个control token（这次是生成熟悉的内容，还是生成探索性的，这个感觉可以搞2个special token）来多任务sft * 数据处理：对exploration-driven placement的样本加权，对超热门episode(item)做popularity capping * serving：加了一路召回，没有细讲，看着有一些cache，应该是近线 ![](/files/ymTL04mZqJIR8ucnh9tb) soft token参考[Embedding-to-Prefix: Parameter-Efficient Personalization for Pre-Trained Large Language](https://arxiv.org/pdf/2505.17051)，这篇是把emb过了mlp后，拼在最前面，而现在这篇是拼在中间，实现方式(gpt教的)： ```python ''' input_ids: [B, T]; user_emb: [B, D_user]''' token_emb = lm.get_input_embeddings()(input_ids) # [B, T, H] soft_user = proj_mlp(user_emb).unsqueeze(1) # [B, 1, H] '''假设 system instruction 长度固定为 sys_len''' inputs_embeds = torch.cat( [ token_emb[:, :sys_len, :], soft_user, token_emb[:, sys_len:, :] ], dim=1 ) soft_mask = torch.ones(input_ids.size(0), 1, device=input_ids.device, dtype=torch.long) attention_mask = torch.cat( [ attention_mask[:, :sys_len], soft_mask, attention_mask[:, sys_len:] ], dim=1 ) outputs = lm( inputs_embeds=inputs_embeds, attention_mask=attention_mask, labels=labels_shifted_if_needed ) ``` ### 华为的KAR [Towards Open-World Recommendation with Knowledge Augmentation from Large Language Models](https://arxiv.org/pdf/2306.10933) ![](/files/0OdZv54UNbtkNEA9aiah) * LLM生成user侧的preference reasoning知识 * LLM生成item侧的factual知识 * 这两部分知识输入一个encoder得到两个表示，然后再过个mmoe产出merge后reasoning augmented vec和fact augmented vec，一起作为CRM的输入特征。 对应的prompt如下： ![](/files/nzxrxMVk7epo9pCEx7S4) 看实验应该是用在召回，每个user和vec去找最像的k个item，但没法ann，只能暴力算 代码：，其实就是把模型输出的hidden states处理一下： ```python x = tokenizer(x, padding=True, truncation=True, max_length=512, return_tensors="pt", return_attention_mask=True).to(device) mask = x['attention_mask'] outputs = model(**x, output_hidden_states=True, return_dict=True) pred = get_paragraph_representation(outputs, mask, aggregate_type) def get_paragraph_representation(outputs, mask, pooler='cls', dim=1): last_hidden = outputs.last_hidden_state hidden_states = outputs.hidden_states # Apply different poolers if pooler == 'cls': # There is a linear+activation layer after CLS representation return outputs.pooler_output.cpu() # chatglm不能用，用于bert elif pooler == 'cls_before_pooler': return last_hidden[:, 0].cpu() elif pooler == "avg": return ((last_hidden * mask.unsqueeze(-1)).sum(dim) / mask.sum(dim).unsqueeze(-1)).cpu() elif pooler == "avg_first_last": first_hidden = hidden_states[1] last_hidden = hidden_states[-1] pooled_result = ((first_hidden + last_hidden) / 2.0 * mask.unsqueeze(-1)).sum(dim) / mask.sum(dim).unsqueeze(-1) return pooled_result.cpu() elif pooler == "avg_top2": second_last_hidden = hidden_states[-2] last_hidden = hidden_states[-1] pooled_result = ((last_hidden + second_last_hidden) / 2.0 * mask.unsqueeze(-1)).sum(dim) / mask.sum(dim).unsqueeze(-1) return pooled_result.cpu() elif pooler == 'len_last': # 根据padding方式last方式也不一样 lens = mask.unsqueeze(-1).sum(dim) # index = torch.arange(last_hidden.shape[0]) # print(index) pooled_result = [last_hidden[i, lens[i] - 1, :] for i in range(last_hidden.shape[0])] pooled_result = torch.concat(pooled_result, dim=0) return pooled_result.cpu() elif pooler == 'last': if dim == 0: return last_hidden[-1, :, :] else: return last_hidden[:, -1, :] elif pooler == 'wavg': # Get weights of shape [bs, seq_len, hid_dim] weights = ( torch.arange(start=1, end=last_hidden.shape[1] + 1) .unsqueeze(0) .unsqueeze(-1) .expand(last_hidden.size()) .float().to(last_hidden.device) ) # Get attn mask of shape [bs, seq_len, hid_dim] input_mask_expanded = ( mask .unsqueeze(-1) .expand(last_hidden.size()) .float() ) # Perform weighted mean pooling across seq_len: bs, seq_len, hidden_dim -> bs, hidden_dim sum_embeddings = torch.sum(last_hidden * input_mask_expanded * weights, dim=dim) sum_mask = torch.sum(input_mask_expanded * weights, dim=dim) pooled_result = sum_embeddings / sum_mask return pooled_result.cpu() else: raise NotImplementedError ``` ### 华为的LLMTreeRec [LLMTreeRec: Unleashing the Power of Large Language Models for Cold-Start Recommendations](https://arxiv.org/pdf/2404.00702) ### 华为的LASER [Efficiency Unleashed: Inference Acceleration for LLM-based Recommender Systems with Speculative Decoding](https://arxiv.org/pdf/2408.05676) SIGIR25 ![](/files/F3hjqLn4xz1SBwnhPoNQ) ### 小红书的NoteLLM [WWW'24 | 小红书NoteLLM: 大语言模型用于I2I笔记推荐](https://mp.weixin.qq.com/s/jcj4jKaEIg-L264uZgYuAw) [NoteLLM: A Retrievable Large Language Model for Note Recommendation](https://arxiv.org/pdf/2403.01744) 3个任务： * I2I笔记推荐任务: 给定目标笔记，基于LLM从内容池中找出top-k个相似笔记 * 主题标签生成任务：基于笔记的标题和内容, 用LLM生成对应的k个主题标签。 * 类目生成任务：基于笔记的标题、内容、主题标签，用LLM生成对应的类目。 笔记压缩prompt： ``` [bos]The compression word is:"[EMB]".[eos] ``` 其中的\[EMB]是一个特殊token，类比bert里的\[CLS] ![notellm](/files/P17j6cGuuhBxWQUuc7lm) #### 生成式对比学习 生成式对比学习(Generative-Contrastive Learning,GCL) * 通过统计共现信息，同时打压热门，得到item pair对 * 由于LLMs的自回归特性, 将\[EMB]的**前一个token**对应的**最后一个隐层输出**经过一个linear layer得到一个d维向量 对于batchsize=B的batch来说，有B个pair对，即2B个item，那么对它们算一个对比学习的loss，其中的sim是cos相似度： $$ L\_{c l}=-\frac{1}{2 B} \sum\_{i=1}^{2 B} \log \frac{e^{\operatorname{sim}\left(\boldsymbol{n}\_i, \boldsymbol{n}*i^{+}\right) \cdot e^\tau}}{\sum*{j \in\[2 B] \backslash{i}} e^{\operatorname{sim}\left(\boldsymbol{n}\_i, \boldsymbol{n}\_j\right) \cdot e^\tau}} $$ #### 协同监督微调 协同监督微调(Collaborative Supervised Fine-Tuning,CSFT)将主题标签生成任务和类目生成任务联合训练，一个batch里40%的样本执行主题标签生成任务，剩下的60%做类目预测任务，然后走正常的语言模型自回归任务： $$ L\_{g e n}=-\frac{1}{T} \sum\_{i=1}^T \log \left(p\left(o\_i \mid o\_{\ 简单总结： 拿推荐数据对llama2做sft，再用CoT的prompt让llama2对user+item+label产出一个推理过程，并通过bge得到emb，构建一个CoT数据集。在线拿当前用户+item的特征从这个数据集里ann出k个cot example的emb，和其他特征一起输入一个decoder，输出给推荐模型的sharebottom，额外加了一个CoT emb的重建loss。 文中用到的instruction prompt参考（Recsys23的[TALLRec: An Effective and Efficient Tuning Framework to Align Large Language Model with Recommendation](https://arxiv.org/pdf/2305.00447)和WWW24的[ReLLa: Retrieval-enhanced Large Language Models for Lifelong Sequential Behavior Comprehension in Recommendation](https://arxiv.org/pdf/2308.11131)），把推荐变成了一个让模型输出yes/no的2分类任务。这里的$$x\_i$$是包括用户特征和当前item特征的文本描述，$$y\_i$$是点击的label(0/1)。 ![](/files/SVNGEkjCY7L3fgt2tzBo) 整体的框架如下： ![](/files/pLcq7tkdjiRayVXAAwyz) * 离线： * finetune LLM使其具有推荐能力 * 使用CF的信息生成CoT Reasoning * 构造一个in-context CoT数据集 * 在线： * 检索和用户相似的in-context CoT examples，学习世界知识和Reasoning指导的CF特征，拿来给推荐系统用 #### 离线部分 **recgen-llama** 如果直接用TALLRec的方法，会有灾难性遗忘，模型在原来的LLM benchmark上效果会下降很多，提出了一种简洁高效的全量参数微调方法，在general data和推荐能力上找到平衡，可能的做法 * base：不微调，原始llama2 * half：用一半的推荐数据全量参数微调 * full：用全量推荐数据全量参数微调 * LoRA：对Q和V矩阵加LoRA，设置rank=8 * 加噪声：[NEFTune: Noisy Embeddings Improve Instruction Finetuning](https://arxiv.org/pdf/2310.05914)和[HyPe: Better Pre-trained Language Model Fine-tuning with Hidden Representation Perturbation](https://arxiv.org/pdf/2212.08853)，用推荐数据finetune的时候，在input的embedding层加噪声 * R3F：[Better Fine-Tuning by Reducing Representational Collapse](https://arxiv.org/pdf/2008.03156)基于置信域的逼近 * Wise-FT：[Robust Fine-Tuning of Zero-Shot Models](https://arxiv.org/pdf/2109.01903)，这个引用量挺高的，，将pretrained和finetuned的权重加权融合：$$W\_{\text {ensemble }}=\alpha \cdot W\_{\text {fine-tuned }}+(1-\alpha) \cdot W\_{\text {pre-trained }}$$ * RecGen：[How Abilities in Large Language Models are Affected by Supervised Fine-tuning Data Composition](https://arxiv.org/pdf/2310.05492)发现通过mixed-data finetuning能够保持通用能力的情况下，提升数学和代码能力 对比下来发现，R3F在推荐和MMLU上都最差，full在推荐上效果最好但在MMLU上不太行，RecGen在推荐的效果还不错在MMLU也没降多少，所以将推荐数据和通用数据(如LIMA([Lima: Less is more for alignment](https://arxiv.org/pdf/2305.11206))和alpaca-gpt4([Instruction tuning with gpt-4](https://arxiv.org/pdf/2304.03277)))混合。 **CoT Reasoning生成** 通过如下的CoT prompt $$\mathcal{P}$$，可以实现如下过程： * 用RecGen-llama系统性地分析用户的交互历史和反馈，建立一个详细的用户profile。 * RecGen-llama对目标的新商品进行特征的详细描述。 * RecGen-llama考虑用户画像与目标商品特性之间的契合度。 * RecGen-llama反思用户在购买中可能对多样化的需求。 即RecGen-llama的输出是 $$ c\_i=\operatorname{RecGen}-\operatorname{LLaMA}\left(\mathbf{x}\_{\mathbf{i}}, y\_i, \mathcal{P}\right) $$ 其中的CoT prompt $$\mathcal{P}$$是： ``` <> As an AI model developed for analyzing consumer behavior, your task is to generate a chain of thought that considers the following points: 1. Utilize the user's interaction history and review comments to summarize their profiles. 2. Introduce the target new item and detail its features precisely. In addition, integrate information about items related to the current target new item ... 1. Contemplate the alignment between the user's profile and the features of the target item. 2. Reflect on the user's potential desire for diversity in their purchases. Your output should be a clear and logical chain of thought... Ensure your analysis is impartial... Focus should be on understanding factors that influence the user‘s decisionmaking regarding the target item. <> Please generate a chain of thought based on the user‘s … considering how these might relate to their interest in the target new item. {Recommendation Features} User's decision-making: The user {Ground-Truth Label} the target new item. Let's think step by step and develop the chain of thought for the above considerations. Commence with the chain of thought immediately: --------------- <> 作为一个用于分析消费者行为的AI模型，您的任务是生成一条思维链，考虑以下几点： 1. 利用用户的互动历史和评论总结他们的个人画像。 2. 介绍目标新商品并详细说明其特点。此外，整合与当前目标新商品相关的其他商品信息。 3. 思考用户画像与目标商品特性之间的契合度。 4. 反思用户在购买中可能对多样化的需求。 您的输出应当是一个清晰且逻辑严谨的思维链，确保您的分析公正无偏，重点应放在理解影响用户决策的因素。<> 请生成一个思维链，基于用户的……考虑这些因素可能如何影响他们对目标新商品的决策。 {Recommendation Features} 用户的决策：用户 {Ground-Truth Label} 目标新商品。 让我们一步一步地开发上述考虑因素的思维链。 立即开始思维链： ``` 从原始的推荐数据集随机sample出M个$$(x\_i, y\_i)$$，生成对应的$$c\_i$$，可以得到CoT数据集：$$C=\left{\left(\mathbf{x}*m, c\_m, y\_m\right)\right}*{m=1}^M$$ **性能分析** * 训练：发现相比用全量数据训练，用一半的数据训出来的模型在MMLU上效果更好，在推荐上的效果差不多，所以可以用小数据集来finetune * 生成：对比[Towards Open-World Recom- mendation with Knowledge Augmentation from Large Language Model](https://arxiv.org/pdf/2306.10933)提出的KAR(用户特征和item特征相对固定，可以提前存生成结果)，LLM-CF应用的场景有很多新用户和新item，但并不需要流式更新 #### 在线部分 ![](/files/iTZfta6xxxmljaWo8mQY) **In-context CoT Examples Retrieval** 对于上面的CoT数据集，拿$$x\_i$$对应的文本$$x\_i^t$$作为query，而数据集$$C$$里的$$M$$个examples对应的key是$$\mathcal{K}=\left\[\mathbf{x}\_1^t, \ldots, \mathbf{x}\_m^t, \ldots, \mathbf{x}\_M^t\right]$$。 先通过BGE embedding([C-Pack: Packed Resources For General Chinese Embeddings](https://arxiv.org/pdf/2309.07597))作为encoder把query $$x\_i^t$$和keys $$\mathcal{K}$$转成向量$$\mathbf{e}\left(\mathbf{x}\_i^t\right), \mathbf{e}(\mathcal{K})=\operatorname{encoder}\left(\mathbf{x}\_i^t\right), \text { encoder }(\mathcal{K})$$ 然后通过ANN找出top K个examples $$\mathcal{I}\_i=\left{\mathcal{E}\_1, \ldots, \mathcal{E}\_k, \ldots, \mathcal{E}\_K\right},\ \mathcal{E}\_k=\left(\mathbf{x}\_k, c\_k, y\_k\right)$$ 做了2个trick： * 避免穿越，保证$$\mathcal{I}\_i$$不包括$$x\_i$$未来的steps的交互信息 * 为了让正负例比例对下游任务不造成影响，保证$$\mathcal{I}\_i$$中的正例和负例比例是1:1 **In-context Chain of Thought Module** ICT模块将$$\mathcal{I}\_i$$当成in-context examples，并把$$x\_i$$当成query，对应的ICT tokens就是 $$ \mathbf{T}=\left\[\mathbf{x}\_1, c\_1, y\_1, \ldots, \mathbf{x}\_K, c\_K, y\_K, \mathbf{x}\_i\right] $$ 然后得到这些token对应的embs： $$ \mathbf{E}=\left\[\mathbf{r}\_1, \mathbf{c}\_1, \mathbf{l}\_1, \ldots, \mathbf{r}\_K, \mathbf{c}\_K, \mathbf{l}\_K, \mathbf{r}\_i\right] $$ 其中，（图中右上角橙色部分） * 文本特征同样经过BGE encoder， * $$x\_i$$里的推荐特征则经过推荐模型的feature encoder得到$$r\_i$$， * CoT reasoning $$c$$则是通过text encoder和MLP映射 * label $$l$$也是一个0/1的id对应的embedding 然后把$$\mathbf{E}$$经过若干层transformer decoder，得到输出的表示: $$ \left.\mathbf{H}=\left\[\mathbf{h}\left(\mathbf{r}\_1\right), \mathbf{h}\left(\mathbf{c}\_1\right), \mathbf{h}\left(\mathbf{l}\_1\right), \cdots, \mathbf{h}\left(\mathbf{r}\_i\right)\right)\right]=\operatorname{Decoder}(\mathbf{E}) $$ 最终得到的表示可以是这个输出的last hidden state：$$\mathbf{w}=\mathbf{h}\left(\mathbf{r}\_i\right)$$ 在各数据集上评估时，发现CoT examples的个数K=4效果就不错了，对应的ICT tokens $$T$$的长度也只有12左右。 **Model Training** 原来推荐的loss是$$\mathcal{L}\_o^i$$，这里加上一个对CoT examples的emb的重建loss： $$ \mathcal{L}*r^i=\frac{1}{K} \sum*{i=1}^K\left(1-\frac{\mathbf{c}\_i \cdot \mathbf{h}\left(\mathbf{r}\_i\right)}{\left|\mathbf{c}\_i\right|\left|\mathbf{h}\left(\mathbf{r}\_i\right)\right|}\right) $$ 最终的loss如下 $$ \mathcal{L}=\frac{1}{N} \sum\_{i=1}^N\left(\alpha \mathcal{L}\_r^i+\mathcal{L}\_o^i\right) $$ **Efficiency Analysis of Online Service** 图中的蓝色火焰部分需要在线计算，而因为$$K=4$$，所以很轻量 ### 丰田的SimUSER [SimUSER: Simulating User Behavior with Large Language Models for Recommender System Evaluation](https://arxiv.org/pdf/2504.12722) 两阶段方法： * 自一致的用户画像匹配，利用LLM从历史数据中抽取个性特征； * 推荐系统评估，模拟具有个性、记忆、感知和决策模块的用户与推荐系统进行互动。 ### 腾讯的ECR Recsys24 [RecSys'24最佳长论文|腾讯ECR:富有情感的对话式推荐系统](https://mp.weixin.qq.com/s/K9LUSywox6IeAb4XIhe_qA) [Towards Empathetic Conversational Recommender Systems](https://arxiv.org/pdf/2409.10527) ### OPPO的DLLM2REC（没落地） 在蚂蚁的SLIM的基础上，希望将LLAMA进一步压缩至更小的序列模型。在实验中遇到几个挑战： * 蒸馏过程中教师模型的知识可靠性存疑 * 从语言模型到序列模型的蒸馏跨越了不同的模型类型，带来两个主要问题： * 参数差距大，学生模型难以容纳教师模型的知识 * 语义不一致，因为序列模型与原始语言模型之间存在天然差异 [Distillation Matters: Empowering Sequential Recommenders to Match the Performance of Large Language Models](https://arxiv.org/pdf/2405.00338v1) ![dllm2rec](/files/Lr5C8J1HlEP5kQ6wq9Rb) 包含两个关键部分：基于Ranking的蒸馏策略(Importance-aware Ranking Distillation)和Embedding对齐(Collaborative Embedding Distillation) 核心在于排名蒸馏，采取了如下三个策略 * 选择LLAMA2作为教师模型，认为其排名靠前的分值更高； * 考虑LLM生成的描述与目标物品（Target Item）的接近程度，增加其排名； * 若教师模型（Teacher Model）认为某物品是优质且排名靠前的，学生模型（Student Model）也会给予其更高排名。 通过这些策略，设计了Ranking Loss，用于蒸馏小型序列模型 $$ \mathcal{L}*d=-\sum*{s \in \Gamma} \sum\_{i \in O^T} w\_{s i} \log \sigma\left(\hat{y}\_{s i}\right) $$ 其中，$$O^T$$是teacher返回的topk结果，$$\Gamma$$是训练集的序列数，$$w\_{\mathrm{s} i}=\gamma\_p \cdot w\_{\mathrm{s} i}^p+\gamma\_c \cdot w\_{\mathrm{s} i}^c+\gamma\_o \cdot w\_{\mathrm{s} i}^o$$，包括如下3部分： * position-aware weight：$$w\_{\mathrm{s} i}^p \propto \exp \left(-r\_i / \beta\right)$$，$$r\_i$$是item $$i$$在teacher返回结果里的排名，$$\beta$$是一个超参 * confidence-aware weight：$$w\_{\mathrm{s} i}^c \propto \exp \left(-d\_{\mathrm{s} i^*} / \beta\right)$$，且$$d\_{\mathbf{s} i^*}=\left|\mathbf{z}*{d*{\mathrm{s}}}-\mathrm{z}*{i^\*}\right|^2$$，$$\mathbf{z}*{d\_{\mathrm{s}}}$$是生成的item描述，$$\mathrm{z}\_{i^\*}$$是ground truth的item描述，分别通过一个llm encoder得到向量 * consistency-aware weight：同时被teacher和student推荐的item更有可能是一个强正例 $$ w\_{\mathrm{s} i}^o= \begin{cases}1, & i \in O^T \cap O^S \ 0, & i \notin O^T \cap O^S\end{cases} $$ ### Spotify的NEO [A Unified Language Model for Large Scale Search, Recommendation, and Reasoning](https://arxiv.org/pdf/2603.17533) 额外使用了`[SID]`和`[/SID]` ![](/files/r1fZtNiByfArcd4TksCz) ![](/files/1U8P9Y8jubbjbuKuYQnK) ![](/files/52LwWHPatqQfJbUvYBYt) ## LLM+推荐：输入文本/ID（学术界） ### P5 RecSys22 [Recommendation as Language Processing (RLP):A Unified Pretrain, Personalized Prompt & Predict Paradigm (P5)](https://arxiv.org/pdf/2203.13366.pdf) ### GReaT ICLR23 [Language Models are Realistic Tabular Data Generators](https://arxiv.org/pdf/2210.06280) ICLR2023， 通过自回归的LLM合成（synthesize）逼真的（realistic）表格化（tabular）数据 ![](/files/uhaVEOPS0x2ow1R0hFml) finetune： * 把表格转化为逗号分隔的自然语言 * 随机交换几个属性的位置得到训练语料 * 基于交换后的语料进行自回归的finetune ![](/files/N7jXTX8E6aTHM97LeFeJ) sample： * 基于如下3种方式产出precondition： * 只输入属性名，例如“年龄” * 输入name-value pair，例如“年龄=26岁” * 输入多个name-value pair：例如“年龄=59岁，教育程度是硕士” * 然后调用LLM输出其他属性 * 再转化为表格格式 ### 微软的RecExplainer [RecExplainer: Aligning Large Language Models for Explaining Recommendation Models](https://arxiv.org/pdf/2311.10947) 新的一篇 [Avoid Recommending Out-of-Domain Items: Constrained Generative Recommendation with LLMs](https://arxiv.org/pdf/2505.03336) * RecLM-ret通过检索机制，从域数据集中找到最相关的item * RecLM-cgen则使用约束生成策略，限制模型仅生成域内的item标题。 ### CUP没中 [Recommendations by Concise User Profiles from Review Text](https://arxiv.org/pdf/2311.01314) 把用户的一堆历史评论扔给chatgpt，让它总结出128个token，然后丢给双塔bert，另一个塔是item的描述，freeze bert底层，只tune上层 ### LLaMA-E 没中 [LLaMA-E: Empowering E-commerce Authoring with Object-Interleaved Instruction Following](https://arxiv.org/pdf/2308.04913) 整体流程 ![](/files/nolBurjVRwxR1p14m0qI) * instruction formulating: 为图中的任务写300个种子指令 * seller $$$$：商家，包括商品名、风格、品牌等 * customer $$$$： * explicit feature $$\$$：用户的历史交互商品 * implicit feature $$\$$：根据历史交互推断出来的潜在兴趣 * platform $$

$$：为商家和用户建立链接 * product correlation $$\$$：不同商品间的差异和联系 * platform background $$\$$：不同电商平台的背景知识 * instruction expansion: 让gpt作为teacher，对300个种子指令进行扩展，并由领域专家评估后，去重并保证质量，得到120k个指令作为训练集 * 针对结果是严格预定义好的，只重写instruction ``` [INST] Rewrite the following instruction while maintaining semantic consistency: [/INST] ``` * 针对鼓励生成结果有多样性的， * 结果生成：用上面重写过的instruction给LLM来获取结果 ``` [INST] [/INST] ``` * 结果重写：拿生成的结果给LLM生成更多样的表达 ``` [INST] Rewrite the following generated response to diversify its expression: [/INST] ``` * instruction tuning: 对self-attention的q、k、v、o参数进行lora 设计的任务 ![](/files/Ngq6r6BLgsCxdgqspiHn) 示例： | Task | Expanded Instructions | | ---------------------------------- | -------------------------------------------------------------------------------------------- | | **Ads Generation** | Produce an advertisement for the specified product. | | | Create an advertisement for the specified product. | | | Produce an advertisement for the product mentioned below. | | | Generate an ad designated for the following product. | | | Prepare an advertisement for the product provided below. | | **Query-enhanced Title Rewriting** | Rephrase the subsequent product title along with the query. | | | Revise the subsequent product title alongside the query. | | | Revise the product title below, incorporating the given query. | | | Revise the given product title in combination with the query. | | | Incorporate the following query to rewrite the product title. | | **Product Classification** | To which category does the subsequent product belong? | | | Which category of this product belongs? | | | Identify the category to which the following product belongs. | | | What category does the listed product belong to? | | | Identify the category of the listed product. | | **Purchase Intent Speculation** | Which category does the provided query imply the customer is interested in? | | | Based on the following query, which category does it indicate the customer is interested in? | | | What category is suggested by the following customer query’s apparent interest? | | | What category does the given query indicate the customer’s interest in? | | | Identify the category that the following query suggests the customer is interested in. | | **General E-commerce Q\&A** | How are my orders attributed to Offsite Ads? | | | Describe the process of attributing my orders to Offsite Ads. | | | Can you explain how my orders are attributed to Offsite Ads? | | | Please elaborate on the process of attributing my orders to Offsite Ads. | | | How are my orders linked to Offsite Ads? | 对应的中文： | 任务 | 扩展说明 | | ------------- | ----------------------- | | **广告生成** | 为指定的产品制作一则广告。 | | | 为指定的产品创建一则广告。 | | | 为以下提到的产品制作一则广告。 | | | 为以下产品生成一则广告。 | | | 为提供的产品准备一则广告。 | | **查询增强的标题重写** | 根据查询改写后续的产品标题。 | | | 根据查询修改后续的产品标题。 | | | 根据提供的查询修改以下的产品标题。 | | | 将给定的查询与产品标题结合进行修改。 | | | 使用以下查询重写产品标题。 | | **产品分类** | 以下产品属于哪个类别？ | | | 这个产品属于哪个类别？ | | | 确定以下产品属于哪个类别。 | | | 列出的产品属于哪个类别？ | | | 确定列出产品的类别。 | | **购买意图推测** | 提供的查询暗示用户感兴趣的类别是哪个？ | | | 根据以下查询，用户可能感兴趣的类别是什么？ | | | 以下用户查询暗示的兴趣类别是什么？ | | | 给定的查询表明用户感兴趣的类别是什么？ | | | 确定以下查询暗示用户感兴趣的类别。 | | **通用电商问答** | 我的订单是如何归因到站外广告的？ | | | 描述我的订单归因到站外广告的过程。 | | | 你能解释一下我的订单是如何归因到站外广告的吗？ | | | 请详细说明我的订单归因到站外广告的过程。 | | | 我的订单是如何与站外广告关联的？ | ### EcomGPT AAAI24 [EcomGPT: Instruction-tuning Large Language Model with Chain-of-Task Tasks for E-commerce](https://arxiv.org/pdf/2308.06966v1) 清华，AAAI 24 ![](/files/KBLS5hX0RvA6yUWk15R6) 设置一系列的task(100多个task)来finetune BLOOMZ(OPT+BLOOM的instruction-following模型) * 命名实体识别：输入描述，输出brand、attr、component、product等 * 描述生成：输入query和候选doc list，选出最match的k个 * 对话intent提取：输入对话和候选intents（使用咨询、恢复订单、退款异常等），选出对应intent ### SAGCN ACM TOIS [Understanding Before Recommendation: Semantic Aspect-Aware Review Exploitation via Large Language Models](https://arxiv.org/pdf/2312.16275) 通过LLM标识出用户对item的评论是属于哪些aspect的，然后u有A个emb，i也有A个emb，构建A个U-I图，然后揉在一起过GCN ![](/files/dgnuGadbAhzu5FRfvcm7) * 拿一些数据先用prompt1让LLM粗略标出用户评论所属的aspects，然后merge并去重得到候选的aspects列表 * 把这个候选aspects列表（图中的蓝色文字）丢给prompt2，让LLM对所有用户的评论打标 然后为每个aspect构建一个graph，过GCN ![](/files/nl0Pw3XdmnGO8nv1fRX9) ### ONCE WSDM24 [ONCE: Boosting Content-based Recommendation with Both Open- and Closed-source Large Language Models](https://arxiv.org/pdf/2305.06566) WSDM24 ![](/files/rrcJxUolRK4hkOeuOf6K) * GENRE(generative recommendation)：闭源LLM产出数据 * user profiler: 输入用户行为历史得到的user profile，例如topics有哪些，地区是哪里，过完content encoder后，把对应的topics和地区的emb pooling一下，得到用户的profile表示 * content summarizer: 输入item的文本content得到的总结 * personalized content generator：输入新用户（readlist<5）比较短的历史，合成这个用户可能比较感兴趣的内容 * DIRE(discriminative recommendation)：对开源LLM进行改造 * 最后一层降维，并过一个attention得到一个表示 * 对32层的llama-7b，只用lora训练最上面的2层 * ONCE： * GENRE产出的文本经过DIRE得到输出，其中user profiler用上面的方法处理一下，再和历史items的content summarizer的输出、personalized content generator的输出concat并过mlp得到user vec * item content的文本经过DIRE得到item vec * u和i算内积，学ctr 其中GENRE的3种数据如下： ![](/files/WGnk7y8HqGFlqInOcbOb) ### Agent4Rec SIGIR24 [On Generative Agents in Recommendation](https://arxiv.org/pdf/2310.10108.pdf) SIGIR24 核心代码是，可以发现是用了langchain，包括其中的memory(请求openai的emb接口，本地faiss存)。 1000个真实用户，初始化1000个agent，3个数据集，搞了3000个agent，Agent模拟人的行为，点击、翻页、退出、打分、评价，评价标准：是否真的拟人 整体流程： * 先在公开数据集上训一个推荐模型（mf/lightgcn等） * 构建1000个agent，模拟和这个推荐模型交互，生成一些新的样本（假设推荐了xxx，你是不是会点？点了，正样本，没点负样本之类的） * 加上这些新的样本再去重训推荐模型，发现效果有提升 ![](/files/Ya3yg0L2VyMmDvdBsrTC) 3个module： * Profile module: * 电影profile（流行度等+电影信息丢给gpt4产出的summary） * 用户profile（社交属性、活跃度、从众心理（conformity）、diversity(更喜欢探索还是利用)、用户喜好tastes（用户历史行为丢给gpt4，让它总结用户喜欢什么不喜欢什么，会在用户有新行为后再update一下）） * memory module: * factual memory: 过去看了哪些电影、动作是什么 * emotional memory: 看完后的情绪表达 * action module: * 看/打分/反馈 * 满意度 * 翻页/退出 图中的推荐系统是一个现成的系统/算法，例如MF、lightgcn等 word版的笔记： ### RecPrompt CIKM24 [RecPrompt: A Self-tuning Prompting Framework for News Recommendation Using Large Language Models](https://arxiv.org/pdf/2312.10463) CIKM24 ![](/files/KtNj0sH3jTB5Sbf38AAe) 如图的loop，所有LLM都是调接口的，没有tune * news recommender：一个LLM，输入prompt如下，结果包括排序的list $$\boldsymbol{R}\_u$$以及解释$$TP\_u$$(用户点击历史总结出来的topic list和对应的新闻list) ``` You serve as a personalized news recommendation system. + Input Format + User's History News ${history} + Candidate News ${candidate} + Output Format Rank candidate news based on the user’s history news in the format: "Ranked news: C#, C#,..., C#". ``` * prompt optimizer：另一个LLM，用于生成更好的prompt。包括： * refinement instruction * 推荐prompt * recommender的回答：$$\boldsymbol{R}\_u$$、$$T P\_u$$ * ground truth $$y\_u$$， * monitor给出的最佳template * observation instruction。 其中，refinement instruction形如： ``` You should generate an improved template instruction based on the provided information. ``` observation instruction形如： ``` You should focus on how well the recommender’s response aligns with the user’s click behavior by examining if the topics from the user’s news history and candidate news are accurately summarized and matched to the user’s interests. Specifically, evaluate the clarity of topics in the recommender’s answer, review the task description for adequacy, and check the detail in the recommendation process to ensure it reflects an analysis and summary of user-interest topics. ``` * monitor：对推荐list和ground truth计算MRR、ndcg，判断当前template是否比之前的有提升 * 衡量效果：看解释$$TP\_u$$提取的topic的准确性和完整性： * 准确性：分母是预测出来的n个topic，分子是有多少个和对应的文章topic是match的 * 完整性：分母是用户历史点过的topic数，分子是用户历史点过的文章数 ### PO4ISR 没中 [Large Language Models for Intent-Driven Session Recommendations](https://arxiv.org/pdf/2312.07552) ![](/files/orM6WOasvWMpo9MHiIHi) * PromptInit：初始化prompt1，输入的数据填充prompt2 * PromptOpt：通过self-reflection来优化初始prompt： * 收集error cases并用prompt3来让LLM想出可能原因 * LLM想出的原因+prompt4来refine出一个prompt5 * 基于prompt5+prompt6来改写/增强出一个prompt7 * 基于prompt5和prompt7通过UCB选出一个最优的prompt8 * PromptSel：在3个domain上进行上述迭代，分别得到对应domain的最优prompt，也看了下这3个prompt在其他数据集上的表现，最终选出一个泛化性比较好的 ### Transrec KDD24 [Bridging Items and Language: A Transition Paradigm for Large Language Model-Based Recommendation](https://arxiv.org/pdf/2310.06491) KDD24 核心思想如下： ![](/files/c1nLIIxhcGPi8Nw20arj) 将一个item表示成3部分：id+title+attr，设计三种对应的instruct-tuning任务，其中`||xx||+`是一个特殊标记，类似于标识任务类型，对应的[代码](https://github.com/Linxyhaha/TransRec/blob/main/scripts/training/reconstruct.py)： ```python if args.target == "id": source = "Given the following purchase history of a user: " + "; ".join(titles) + ". " source += "What is the next possible item to be purchased by the user?" source += " || ID" elif args.target == "attribute": source = "Given the following categories of purchase history of a user: " + "; ".join(titles) + ". " source += "What is the category of the next possible item to be purchased by the user?" source += " || attribute" if "\n" in source: source = "".join(source.split('\n')) if args.query_mode == "attribute": targets = ["".join(t.split('\n')) for t in target] if "\n" in target: target = "".join(target.split('\n')) if args.target == "id": target = "|| " + target.strip() + " ##" yield source + " || +", target if args.target == "attribute": for target in targets: target = "## " + target.strip() + " @@" yield source + " || +", target ``` 然后是generation grounding，即引入一个特殊的数据结构（FM-index），并进行constrained beam search，让模型能生成候选集中的id/title/attr，然后再遍历全库候选，看不同facet的相似度（会考虑高热打压），加权融合出一个排序 ![](/files/npqSn9T9oM4Vb0inj3pu) * FM-index：参考[Autoregressive Search Engines: Generating Substrings as Document Identifiers](https://arxiv.org/pdf/2204.10628)：例如一个item可以写成` 1023 Urban Decay Eyeshadow Palette Naked Heat Makeup Eyes `，并通过wavelet tree存储，给定开始token（如``或者``），可以在$$O(Vlog(V))$$里找出所有可能的后续tokens。代码： * constrained beam search：参考[Autoregressive entity retrieval](https://arxiv.org/pdf/2010.00904)：代码：，另外，可以发现title是没有bos和eos的，这样在检索/生成title的时候，是可以检索/生成子串的，也就是论文提到的position-free，同样的方法也可以用在instruct tuning阶段。 ### E4SRec 没中 [E4SRec: An Elegant Effective Efficient Extensible Solution of Large Language Models for Sequential Recommendation](https://arxiv.org/pdf/2312.02443) 代码： ![](/files/zLqyjbHhS2DqocJPMqoc) * 把id引进来：先通过现有的推荐模型（如SASRec）得到id embed，然后通过一个linear得到和原始LLM的emb一样长的dim，再嵌入到llm里去，只有这个linear是可学习的 * LLM的输出：看代码取的是最后一个词的hidden state，再过Linear映射回推荐模型的dim，再过一个softmax映射到id空间（当然，如果要用到工业界可以正常的召回采样方法，如sampled softmax之类的） * infer：和召回一样，ann finetune部分代码的大概逻辑如下： * 输入：把预训练好的item id emb当成一个nn.Embedding搞到模型里去，然后样本里的item id（每个id都是1-n的数）去查出对应的emb，和instruct的emb、response的emb(`### Response：\n`这种文字对应的emb)这3个emb一起concat起来作为模型输入 * label：假设有n个item，因为最后过了个softmax映射到n，所以label就是一个1-n之间的数 infer照理说应该是得到emb，然后去ann，但代码里偷懒了直接拿softmax后的1-n的结果 ### Llama4Rec SIGIR24 [Integrating Large Language Models into Recommendation via Mutual Augmentation and Adaptive Aggregation](https://arxiv.org/pdf/2401.13870) SIGIR 24 ![](/files/n7tq55mwgVKTOSt1i7gC) * prompt增强：在prompt里引入推荐模型的信息 * 相似用户也喜欢item4、item5 * 另一个推荐模型给出的预估是xxx * 数据增强：通过LLM给推荐模型增加样本 * 直接推荐：给定2个候选item，LLM判断哪个更好 * 序列推荐：给定候选list，LLM给出topk * 评分预测：给定候选item，LLM给出打分 * adaptive aggregation：llm和推荐模型都给出排序，然后自定义融合公式算出融合分，得到最终排序 示例prompt如下 ![](/files/vEYYZbOHmDwYOwygQnBN) 通过如上prompt构建一个instruct-tuning数据集，然后finetune一个llama2 ### MACRec SIGIR24 把推荐系统拆成多个agent [MACRec: a Multi-Agent Collaboration Framework for Recommendation](https://arxiv.org/pdf/2402.15235) ### GPLR SIGIR25 [You Are What You Bought: Generating Customer Personas for E-commerce Applications](https://arxiv.org/abs/2504.17304) [NUS-LLM小样本学习助力用户画像建模](https://www.xiaohongshu.com/explore/683b343f0000000022006648?app_platform=ios\&app_version=8.87\&share_from_user_hidden=true\&xsec_source=app_share\&type=normal\&xsec_token=CBjpcluHYwI6-nyp1gVu04fpW4voj7bMwSu2oY88K0f-c=\&author_share=1\&xhsshare=WeixinSession\&shareRedId=ODY2NUg4NE82NzUyOTgwNjY0OTc1STdO\&apptime=1750064425\&share_id=c4b8d3de4af6496692a900106b0640f1) 只对5%-20%的用户用LLM标注，再结合随机游走算法推断全量用户角色，大幅降低标注成本（如1,000万用户年成本由240万降至50万美元）。 * 用户画像的定义与生成: * 多维度可解释表示: 自然语言角色标签，如Bargain Hunters, Health Enthusiasts, Tech Savvy, and Busy Parents。 * LLM驱动的角色生成: * 原型用户标注：利用LLM分析部分原型用户的购买历史，自动生成如“健康生活倡导者”等标签。 * Prompt工程：通过多阶段提示优化(初步生成、去重筛选和用户反馈校验)，最终形成平台专属的角色标签集。 * 小样本LLM标注DUSample(Diversity-Uncertainty，多样性-不确定性): * 从用户中筛选**稀有角色**用户和**高不确定性**用户(如购买行为难以归类的用户), 确保LLM标注的标签具有多样性，避免主流角色主导。 * 通过KL散度和熵计算用户的DU Score，优先标注多样得分高的用户，提升标签覆盖范围。 * 随机游走传播: 用户-商品二分图建模，角色亲和力矩阵: * 通过随机游走概率矩阵计算用户间的行为相似性，结合原型用户的角色标签矩阵，得到所有用户与角色的亲和力; * 假设相似购买行为的用户具有相同角色, 通过加权聚合原型用户的标签推断未标注用户的角色。 * 反向近似算法RevAff： * 反向传播：从原型用户出发，反向计算其他用户的角色亲和力，避免全图矩阵运算。 * 误差控制：通过设定绝对误差阈值，仅保留影响大于阈值的传播路径 * 用户画像与推荐模型集成：将角色表示作为输入特征融入GCN ### guided embedding [Improving LLM Interpretability and Performance via Guided Embedding Refinement for Sequential Recommendation](https://arxiv.org/pdf/2504.11658) guided embedding：prompt里包含m个aspect，让模型给出每个aspect的打分 * guided item emb：当前item在每个espect的打分，一个m维向量… * guided user emb：当前user看过了一些东西，给出这个user在各aspect的打分，也是一个m维向量 2阶段训练 * finetune出guided emb：guided item emb不更新，lora去训练llm以及上层的recommend module(可以通过prompt来设计，例如预测u会不会点item、u对i的打分等)，loss会加一个format的约束，即mask掉预测的得分，只看是否按规定格式输出） * 嵌入现有推荐模型：左边是原来模型的emb模块，产出的u和i的emb，分别和guided u和i的emb做加权拼接，得到refined u和i的emb，再输入后面的模块 ![](/files/dwkpjfgz8r1FMpZCZhOb) 一些相关prompt： * aspect示例： ![](/files/8ykLYsLzKr3FsdfrsARG) * item prompt： ![](/files/cLYB5SwRSY6SDDpTIQsF) * user prompt： ![](/files/iy7azMGux3Zpl91UCVEs) * user review示例： ![](/files/BEloaTG5Gs8ASQ218WER) * item示例： ![](/files/XAVRUzVdhBZbLrp61d2K) ### GMC [Generative Multi-Target Cross-Domain Recommendation](https://arxiv.org/abs/2507.12871) ![](/files/ikbFRD1fmpmfgwSVFg4k) * sid的学习：通过llama3.1-8b-instruct产出4096的emb，然后学一个rq-vae的sid，主要加了一个domain-aware的对比学习（2个item相同domain则拉近距离，反之拉远），所以loss=loss\_reconstruct+loss\_rq+loss\_domain * 推荐模型的学习：一个正常的transformer-based模型(本文用的T5-small)，预测下一个sid * domain-specific的微调：每个domain加一个小矩阵，该domain的数据只用lora训对应的那个小矩阵 ### MiniOneRec [首个完整开源的生成式推荐框架MiniOneRec，轻量复现工业级OneRec！](https://mp.weixin.qq.com/s/lnoLU1fsubtzpefVcTniCA) [MiniOneRec: An Open-Source Framework for Scaling Generative Recommendation](https://arxiv.org/abs/2510.24431) ### LLM-as-a-Judge [LLM-as-a-Judge:Toward World Models for Slate Recommendation Systems](https://arxiv.org/pdf/2511.04541) * 拿LLM来建立一个偏好世界模型，让LLM同时看到不同推荐list，并观察哪一组更符合人类逻辑(通过一些规则设计的，比如随机搞一个list，而用户对这些有过打分/时长之类的后验，定义比如list1里的总打分是5，list2的总得分是3，那list1>list2)。 * 每次判断，模型都会给出理由：例如内容更丰富、和历史兴趣匹配程度等 * 用多个模型投票 ![](/files/MVzNrL8875TaWYd23OW7) ### GREAM [Generative Reasoning Recommendation via LLMs](https://arxiv.org/pdf/2510.20815) ![](/files/w4bvWHRSK7g79HIuctUa) 对比onerec-think，参考[xhs](https://www.xiaohongshu.com/explore/69116fe80000000005011644?app_platform=ios\&app_version=9.7.3\&share_from_user_hidden=true\&xsec_source=app_share\&type=normal\&xsec_token=CBM_Q-ZzmwypmP1eWhgOOwRmru7T5Vv5IrRP1tSa1gWug=\&author_share=1\&xhsshare=WeixinSession\&shareRedId=ODY2NUg4NE82NzUyOTgwNjY0OTc1STdO\&apptime=1762754205\&share_id=1e0e74e1908d4fcb929862735e6a9e3f) ![](/files/vQwZTt147u29pWEwKfTU) ### PersonaX [PersonaX: A Recommendation Agent-Oriented User Modeling Framework for Long Behavior Sequence](https://arxiv.org/pdf/2503.02398v1) ## LLM+推荐：Foundation/蒸馏/其他 ### Google的自进化推荐系统 [Self-Evolving Recommendation System: End-To-End Autonomous Model Optimization With LLM Agents](https://arxiv.org/pdf/2602.10226) ![](/files/XG1XAXMBPWahGbSeDmDw) fast内层循环(offline agent)：输入当前排序模型配置和效果给llm，走think-code-verify循环，自己改代码（layer、优化器、loss、label等），然后在离线数据集上训练模型并重新改代码。有如下3类角色 * Optimizer：使用工具compute\_loss，迭代优化器、超参（bs/动量等），看不同配置下训出来模型的loss差异 * Architecture：使用工具compute\_loss，迭代网络结构 * Reward：使用工具run\_sql\_query，自己分析各label和特征的分布，设计更好的label slow外层循环(online agent)： * offline agent产出的模型配置+人工设计的模型配置 * 选择模型用于训练：过滤掉一些模型，例如编译有问题、模型太大但现有数据不够收敛的模型 * 训练模型 * 自动开在线实验并监控，当指标出问题时会自动停实验 * 记录实验效果，可以给offline agent用 ![](/files/zVPG5WPvwHzk3TLHNx7o) ![](/files/PrRh0bpYmqkMQzPz7fHM) 不同llm的效果差异（越小效果越好）：gemini pro比flash好，角色设置是有用的，对context进行裁剪效果会变差 ### Google的多智能体推荐系统综述 [Multi-Agent Video Recommenders: Evolution, Patterns, and Open Challenges](https://arxiv.org/pdf/2604.02211v1) ![](/files/AGnHjUyY72aPuZX5Zkjc) * 分层编排：一个中心协调智能体，负责指导各专业化从属智能体的动作并整合它们的输出，以实现统一目标。代表工作[MMRF](https://arxiv.org/pdf/2405.01847)、[MMAgentRec](https://pubmed.ncbi.nlm.nih.gov/40199968/) * 基于流水线的模块化协作：智能体按顺序运行，形成一个处理流水线，每个智能体执行一个独特且专门化的任务。前一个智能体的输出直接作为下一个智能体的输入，构建出一种模块化工作流，将复杂问题分解为可管理的阶段。代表工作[VRAgent-R1](https://arxiv.org/pdf/2507.02626)、[MACRec](https://arxiv.org/pdf/2402.15235) * 用户-agent协作：多个智能体内部协作，以驱动单一的、面向用户的对话式接口（位于更广泛的推荐界面之中），其主要目标并非提供推荐，而是赋予最终用户对其推荐内容流的直接、直观控制权，从而增强其“自主感”。代表工作[TKGPT](https://dl.acm.org/doi/epdf/10.1145/3719160.3736628) * 用户仿真智能体集成：将智能体用作用户群体的模拟，而非核心推荐组件。其目标是生成高保真度的合成交互数据，可用于离线评估系统性能、训练其他模型，或研究复杂用户行为现象，而无需承担真实 A/B 测试的成本与风险。代表工作[Agent4Rec](https://arxiv.org/pdf/2310.10108.pdf) ![](/files/aYfVZkHxmaSdCxU5O17h) 评估方式不只是之前的hitrate、ndcg了，还要考虑更多东西，共如下5个维度 * 任务特定质量：感知智能体、推理智能体、专业化推荐器有各自的指标 * 协调与协作效率：通信改期、延迟、贡献对齐（辅助智能体的建议最终是不是提升了主智能体的效果） * 系统级与涌现鹅：鲁棒性&容差、适应性、涌现行为准确率 * 人类对齐与用户中心度量：可控性与自主性、可解释性、可信度、公平性 * 可扩展性与下次i呀可行性：token成本、端到端延迟、训练资源等 ![](/files/WghHmA4WuiGp2HU2pRyB) 挑战： * 计算成本与可扩展性 * 多模态定位与推理 * 评估 * 可控性与可信性 * 激励一致性 未来方向： * 混合RL-LLM架构 * 终身个性化与智能体记忆 * 人机协同验证 * 面向自我改进的推荐系统 MACF这个可以看眼：[Multi-Agent Collaborative Filtering: Orchestrating Users and Items for Agentic Recommendations](https://arxiv.org/abs/2511.18413) ### Google的zero-shot cross-domain KD [Zero-shot Cross-domain Knowledge Distillation: A Case study on YouTube Music](https://arxiv.org/pdf/2603.28994) ![](/files/NuUBuwq7rPRUmkzlrdoc) teacher：视频推荐模型，对音乐样本产出soft label 2个student：2个场景的音乐推荐模型，样本量是teacher的1/150到1/300之间 * Homepage model：ctr和时长这2个head会去蒸馏teacher的打分，而发现性这个head就不去学teacher了，因为teacher没有相似的task * Radio model：推荐的是sequencing music videos，和teacher没有任何一个任务相似。增加一个不serving的head，只学teacher的continue watching任务，表示看完这个视频会不会看下一个 ### Google的AgenticRecTune [AgenticRecTune: Multi-Agent with Self-Evolving Skillhub for Recommendation System Optimization](https://arxiv.org/pdf/2604.26969) [推荐算法工程师要失业了？谷歌让AI自己给自己“调参”，效果竟然碾压人类专家！](https://mp.weixin.qq.com/s/4ySDBeIEVRJorA09reUd3w) 粗排、精排、重排融合公式的自动调参 ![](/files/jm96tM79sbUdWeqsnqKG) Reasoning Loop： actor和critic的prompt： ![](/files/dMDlNFzYsTOT7SybAMcC) ### Meta的ExFM [GPT4规模大模型落地，Meta提ExFM框架：万亿参数基础大模型的工业级落地成为可能](https://mp.weixin.qq.com/s/Y9rlMxg4EMl_bzi9N_s7GA) [External Large Foundation Model: How to Efficiently Serve Trillions of Parameters for Online Ads Recommendation](https://arxiv.org/abs/2502.17494) ![](/files/xAfjqTgeVVNT6v4QbF7m) 图中的$$\Theta^F(t)$$是FM(teacher，foudation model)在$$t$$时刻的参数，$$D^F(t)$$是FM在$$t$$时刻的数据集，V是VM（student, vertical model）的对应参数/数据集 * co-distillation vs external distillation： * co-distillation：联合训练teacher和student，只拿student去serving。 * 缺点：训练成本很高，而且线上链路有多阶段的ranking，为每个ranking模型保留一个大的teacher是低效的 * external distillation：单独训练teacher模型，是1-to-N的模式，一个teacher可以像foudation model一样指导多个student * 流式训练：t时刻的数据训出对应的模型，t+1加载t时刻的数据训练出t+1时刻的模型 * ExFM： * t-1的各VM数据聚合成t-1的FM数据，训练得到t-2的FM模型 * t的各VM数据聚合成的t的FM数据，训练得到t-1的FM模型 * DAS, data augmentation service：FM对每个VM数据进行预估，再加上对应的VM数据，产出VM的训练数据 * Auxiliary Head和Student Adapter：使用DAS产出的数据，基于t-1的VM模型利用AH和SA训练得到t的VM模型 ![](/files/VvLZx7AHkxOb4zQ9qJ47) * 数据集生产： * 将所有VM的特征和真实label聚合成一个shared dataset， * 有很长的时间窗口等待feadback(例如ctr有5-90min，cvr有一天)，在这个窗口中，FM可以使用VM的特征给出预估结果 * 然后从这个shared dataset中取出各VM对应的子数据集用于训练 * FM ckpt的维护和更新： * FM有新的ckpt时，会通过SPD（一个db）发布 * updater从SPD读到最新的ckpt版本，再写到zeus（一个基于zookeeper的分布式metadata存储）里去 * DAS任务从zeus读取最新模型 ![](/files/oEA7W6eIHEuKL9Qz8eUf) 真实label是$$y$$，FM预估出来的label(pseudo-label)是$$\hat{y}^F$$，student包括两部分，backbone $$\mathbf{x}$$和serving head $$\hat{y}^S=\phi(\mathbf{x})$$，其中$$\phi$$是MLP，loss是交叉熵： $$ h(\hat{y}, y)=y \cdot \log (\sigma(\hat{y}))+(1-y) \cdot \log (1-\sigma(\hat{y})) $$ VM的loss是： $$ \mathcal{L}\_{\mathrm{kd}}\left(\hat{y}^S, \hat{y}^F, y\right)=h\left(\hat{y}^S, y\right)+h\left(\hat{y}^S, \hat{y}^F\right) $$ 但用一个head来预估2个label会引入bias，所以引入AH(Auxiliary Head)来预估pseudo-label，即$$\hat{y}^D=\psi(\mathbf{x})$$，其中$$\psi$$是另一个MLP，这样就可以拆成2部分： * 真实label的loss：$$\mathcal{L}\_{\mathrm{s}}\left(\hat{y}^S, y\right)=h\left(\hat{y}^S, y\right)$$ * pseudo-label的loss：$$\mathcal{L}\_{\mathrm{d}}\left(\hat{y}^D, \hat{y}^F\right)=h\left(\hat{y}^D, \hat{y}^F\right)$$ 引入以下3个方法强化FM的蒸馏效果： * gradient scaling(gs)：AH对backbone的梯度乘一个$$\beta$$ * label scaling(ls)：下式中的$$\alpha$$，同时要保证scale完的label不越界，即$$\alpha \cdot \hat{y}^{F M}$$不超过1 * loss weighting(lw)：下式中的$$w$$ $$ \mathcal{L}*{\mathrm{ah}}=\mathcal{L}*{\mathrm{s}}\left(\hat{y}^S, y\right)+w \* \mathcal{L}\_{\mathrm{d}}\left(\hat{y}^D, \alpha \cdot \hat{y}^F\right) $$ 进一步地，在$$\hat{y}^F$$的基础上再过个MLP，得到SA（student adapter）$$\hat{y}^{S A}=\operatorname{MLP}\left(\hat{y}^F\right)$$，相应地，加上一个SA与真实label的loss：$$\mathcal{L}\_{\text {sta }}\left(\hat{y}^{S A}, y\right)=h\left(\hat{y}^{S A}, y\right)$$ 然后，为了不让VM的梯度回传给SA，需要加一个stop-gradient，即$$\mathcal{L}\_{\mathrm{sa}}\left(\hat{y}^D, \mathrm{SG}\left(\hat{y}^{S A}\right)\right)=h\left(\hat{y}^D, \mathrm{SG}\left(\hat{y}^{S A}\right)\right)$$ 整体过程： * 优化SA的参数$$\Theta^{S A}$$：用$$\mathcal{L}\_{\text {sta }}\left(\hat{y}^{S A}, y\right)$$ * 计算$$\operatorname{SG}\left(\hat{y}^{S A}\right)$$ * 优化VM的参数$$\Theta^{V}$$：用$$\mathcal{L}*{\mathrm{ah}}+\mathcal{L}*{\mathrm{sa}}$$ 按自己的理解重新画了下： ![](/files/LGx3DM0rM99ACsmY7UJT) ### Meta的Foundation-Expert Paradigm [Realizing Scaling Laws in Recommender Systems: A Foundation–Expert Paradigm for Hyperscale Model Deployment](https://www.arxiv.org/pdf/2508.02929) ### Meta的LLaTTE [LLaTTE: Scaling Laws for Multi-Stage Sequence Modeling in Large-Scale Ads Recommendation](https://arxiv.org/pdf/2601.20083) ![](/files/PLwcxAtZAma3Mq57Zsgj) * 非序列建模：用DHEN * 序列建模： * transformer用MLA，上游模型的query没有target item的信息，下游模型有 * 金字塔结构：深层扔掉一些老的token，参考字节tt电商的onetrans：[ OneTrans: Unified Feature Interaction and Sequence Modeling with One Transformer in Industrial Recommender](https://arxiv.org/pdf/2510.26104) * readout：把最后一层的query token输出存下来，给下游模型用 ![](/files/24bs9QtM4kH1vdBbYRNf) ### Meta的REA [Ranking Engineer Agent (REA): The Autonomous AI Agent Accelerating Meta’s Ads Ranking Innovation](https://engineering.fb.com/2026/03/17/developer-tools/ranking-engineer-agent-rea-autonomous-ai-system-accelerating-meta-ads-ranking-innovation/) ![](/files/JytTdGUefYOkox4FsHQJ) 基于内部的AI agent框架[Confucius Code Agent: Scalable Agent Scaffolding for Real-World Codebases](https://arxiv.org/abs/2512.10398)构建了REA，该框架专为复杂的多步骤推理任务而设计。它提供了强大的代码生成功能和灵活的SDK，可与Meta的内部工具系统集成，包括作业调度器、实验跟踪基础设施和代码库导航工具。 * 历史洞察数据库：一个精心整理的过往实验资料库，能够从以往的成功和失败中学习和识别相关模式。 * ML研究代理：一个深度研究组件，利用Meta的历史洞察数据库，调查基线模型配置并提出新的优化策略。 在执行任何计划之前，REA会提出详细的探索策略，估算GPU计算总成本，并与工程师确认方案。典型的多阶段计划分为三个阶段： * 验证：对来自不同来源的各个假设进行并行测试，以建立质量基准。 * 组合：将有前景的假设结合起来，以寻求协同改进。 * 优化（密集优化）：积极探索最有希望的候选方案，以在批准的计算预算内最大限度地提高结果。 当REA遇到故障（例如基础设施问题、意外错误或次优结果）时，它会在预定义的安全机制范围内调整计划，而不是等待人工干预。它会参考常见故障模式的运行手册，做出优先级排序决策（例如排除出现明显内存溢出错误或训练不稳定信号（如损失激增）的作业），并从根本上调试初步的基础设施故障。这种弹性对于维持长期任务的自主运行至关重要，因为工程师只需提供定期监督，而无需持续监控。 REA运行采用严格的安全措施。它仅基于Meta的精排模型代码库。工程师通过预先检查清单授予明确的访问权限，REA还会预先确认计算预算，并在达到阈值时停止或暂停运行。 ![](/files/W2rlqbEUk3JiBSKCD9vw) REA由两个相互关联的组件构成：REA规划器和REA执行器，并由一个共享的skill、知识和工具系统提供支持。该系统提供机器学习功能、历史实验数据以及与Meta内部基础设施的集成。它们共同直接实现了代理的三大核心功能。 * 长周期自主性由执行流程驱动：工程师与假设生成器协作，通过REA规划器创建详细的实验计划。该计划导出到REA执行器，执行器通过代理循环和等待状态管理异步作业执行，在训练运行期间进入等待状态，并在完成后恢复运行并返回结果，而无需在长达数周的工作流程中持续进行人工监控。 * 高质量、多样化的假设生成由知识流驱动：当执行器完成实验时，专用的实验记录器会将结果、关键指标和配置记录到集中式的假设实验洞察数据库中。这种持久记忆会积累代理运行完整历史中的知识。假设生成器利用这些洞察来识别模式，从之前的成功和失败中学习，并为后续的每一轮提出越来越复杂的假设，从而形成闭环，并随着时间的推移不断提升系统的智能。 * 弹性执行贯穿于所有流程：当执行器遇到故障、基础设施错误、内存不足信号或训练不稳定时，它会查阅常见故障模式的运行手册，并应用优先级逻辑在预定义的安全范围内自主调整。然后，它会恢复规划器的运行，并提供可操作的结果，而不是向工程师发出例行中断通知。 ### Meta的KernelEvolve [KernelEvolve: Scaling Agentic Kernel Coding for Heterogeneous AI Accelerators at Meta](https://arxiv.org/pdf/2512.23236) ### Meta的MoNN+HILL [Efficient Retrieval Scaling with Hierarchical Indexing for Large Scale Recommendation](https://arxiv.org/pdf/2604.12965) 前序工作：[Hierarchical Structured Neural Network: Efficient Retrieval Scaling for Large Scale Recommendation](https://arxiv.org/pdf/2408.06653)，可以看一下，对下面的一些东西能有更深理解 ![](/files/juKQUowmNNUP6M9hhXBw) ![](/files/WkYHIFdjWrClMeY0Fxg6) Modular Neural Network (MoNN)，召回的foundation model，简单理解就是三塔（u、i、cross）+复杂nn（DHEN、deepfm、wukong等），loss包括两部分，一个是学真实后验，一个是蒸馏teacher的soft label(也是用交叉熵) ![](/files/rzQ2E6JA5GgEqe6lno7u) 其中的cross塔用的是Inverted Index Based Interaction Features（I2IF）： * 提前建好倒排：key：类目/tag，value：item set，以及mean/sum pooling聚合后的item emb * U侧：存好用户最近交互的类目list * 检索：u侧当query，去倒排里检索出来，可以搞出dense特征（检索到的类目emb pooling一下），也可以是sparse特征（match特征） 训练方法如下，简单总结就是，假设总共有K个index 1. 随机找一个u和i的pair对，通过monn得到i的emb,然后拿它和每个index的距离算一个加权和，得到一个伪的item表示，然后拿u和这个伪item去算loss，来更新monn 2. 最后算一个item到index的映射关系，即取离每个item最近的index ![](/files/m5B5193jmIxIKhCd5hPy) 以上是单层的，假设总结有N层，每层都有K个index，那可以用RQ的思想，上面学到的就是第一层的index，对第二层来讲，用item向量和那个伪向量的差当成这层的item表示；直到第N层，每一层都去跑一下algorithm1，只是换item emb，另外最后一层要把前面的item表示全部加起来，得到的表示还要和原始的item向量算重建loss ![](/files/shSWwbT4rtUt3z0k0LTN) 如果资源不够，可以搞一个穷人版：拆成E和M两步， * E-step给每个item分配最近的index，可以直接用faiss或者kmeans * M-step在当前index embedding固定的情况下，去训练foundation model 然后还可以用这个索引来构造新样本，正常来讲beam search搜到的叶子节点这个路径上的节点，用户都应该感兴趣，但不能全用，设置2个超参： 1. 最多回溯多少层 2. 计算一个得分，即这个中间节点的孩子节点里，有多大比例的是用户感兴趣的，得分比较高的时候才保留 设计的是一个3layer的MoNN，顶层粗粒度的用一个大模型来打分，底层item粒度的用一个小模型。最终上线用的是2层 ![](/files/JY1pEhCCJJRChFB7BT4k) ### Meta的SOLARIS [SOLARIS: Speculative Offloading of Latent-bAsed Representation for Inference Scaling](https://arxiv.org/pdf/2604.12110) 当前蒸馏的问题： 1. 只蒸馏logit，transfer ratio低，大概只有20%\~25% 2. 训练时有蒸馏信号，推理时没有 ![](/files/wdUDoxn1JcdQGKmgVQP3) 不只在训练阶段蒸馏，而是在推理阶段也让VM也能用到FM的知识 knowledge sharing * FM兼容性：取FM里各种特征交互后过了一坨nn的最后一个隐层，叫shared output * SOLARIS特征抽取：上面那个shared output过一个autoencoder，把压缩后的表示拿出来给下游用 * 推理时的knowledge sharing：上面的产出，和其他特征一起给下游模型用 Asynchronous Precompute：类似Speculative decoding的思想，每一次请求过来，VM打分高于某个阈值时（或者卡前20%）才认为是高价值的u-i pair对，此时的VM相当于是一个verifier模型，只对这些pair对用FM去计算emb，并cache起来，设置一个TTL Hierarchical Feature Enrichment：原始的覆盖率只有50%左右 * Aggregated user-item Embedding：当前user在过去24小时内所有item取平均，得到u侧表示，能提升覆盖率到85-90% * Similarity-Based Embedding：u找相似用户，拿相似用户的u-i pair来用，能提升30%覆盖率 效果：有业务收益，且迁移率涨到42%左右 ### 虾皮的Sortify [Let the Agent Steer: Closed-Loop Ranking Optimization via Influence Exchange](https://arxiv.org/pdf/2603.27765v1) ![](/files/So94rv5nuel3pBuJspyl) ![](/files/tvKoL6JSMhY7Qtnptnqa) ![](/files/9Jm0eqRRgxvKNJTzgxwA) 写得花里胡哨的，核心 1. 搭了个自动的调参框架（很久以前的AutoML做的事情）， 2. 中间拿llm帮忙生成了2个参数去改intercept和penalty multiplier 3. 历史调参状态、episode、更新记录这些核心记忆放在Memory DB里；搜索出来的参数会通过Redis发布。 2个channel： * Belief channel：其实就是各指标的离线to在线的校准，gmv在线=gmv离线\*slope+intercept * Preference channel：核心是最大化gmv的uplift，但会挤压其他目标（违反约束的会加一个惩罚项，就是下面的penalty） ![](/files/DRjAUfPdndGt7qSnpWgj) 如图，llm * 输入是一个json，即历史调参和ab效果，还有在离线效果，还有当前penalty权重 * 输出是2个数，一个是intercept的变化量，一个是penalty的缩放范围 ### 腾讯的LFM4Ads [Large Foundation Model for Ads Recommendation](https://arxiv.org/abs/2508.14948) ### 蒸馏：SLMRec [ICLR2025 | SLMRec: 重新思考大语言模型在推荐系统中的价值](https://mp.weixin.qq.com/s/E6SGGKy6-D1h3zGro7KW0w) [SLMRec: Distilling Large Language Models into Small for Sequential Recommendation](https://openreview.net/pdf?id=G4wARwjF8M) 提出了一种知识蒸馏的方法，使得小语言模型仅用13%的模型参数，取得了比现有大模型推荐方法略好的效果，并取得了在训练/推理阶段6.6x/8.0x的加速。 ![](/files/RDAOLimQXGwaNmF4i4Jq) * teacher每m层分成一个block，共分为B个block；student每n层分为一个block，也是B个block * 每个block里，算3个loss： * teacher和student间算2个loss：衡量方向的cos相似度，衡量模长的L2距离 * student和真实label（target item）算loss * teacher frozen，只通过lora来训练student ### Pinterest的DERM [推荐算法(2025.9.7)：Pinterest的跨域表征学习](https://mp.weixin.qq.com/s/hI3B6ZefpBDRnsuuHIiRNw) [Decoupled Entity Representation Learning for Pinterest Ads Ranking](https://arxiv.org/pdf/2509.04337) ### 生成式出价：快手的GAVE [sigir'25「快手」生成式出价-冠军方案｜Generative Auto-Bidding with Value-Guided](https://mp.weixin.qq.com/s/fttTPY6Q30gWaSwcoIpUsA) [Generative Auto-Bidding with Value-Guided Explorations](https://arxiv.org/pdf/2504.14587) 用Decision Transformer代替RL，再利用离线强化的方法去弥补没有模拟环境的缺点。DT的一些其他应用： * RAG：[Retrieval-Augmented Decision Transformer: External Memory for In-context RL](https://arxiv.org/pdf/2410.07071) * 序列推荐：[Sequential Recommend for Optimizing Both ImmediateFeedback and Long-term Retention](https://arxiv.org/pdf/2404.03637) * 重排：[PISDR: Page and Item Sequential Decision for Re-ranking Based on Offline Reinforcement Learning](https://raw.githubusercontent.com/mlresearch/v260/main/assets/yuan25a/yuan25a.pdf) MDP假设是状态独立的，本质上忽略了竞价序列中的**时序依赖**关系。 自动出价：一般广告主会设置一个最低ROI（即价值/成本）作为约束，或者说是最大平均成本（CPA，即成本/价值），广告主给定的约束假设是$$C$$。 #### DT ![](/files/XOKS5uzrAFOvPQC2kkqf) [Decision transformer: Reinforcement learning via sequence modeling](https://arxiv.org/pdf/2106.01345)，代码： DT的输入(reward, state, action)三元组的序列，输出是预测的action， **注意：对于t时刻来讲，输入的是0到t-1时刻的r+s+a，但只输入了t时刻的r和s** * $$s\_t$$：历史出价策略、剩余预算、广告的在线时间等 * $$a\_t$$：出价因子，在广告的value上乘以a，$$b\_t=a\_tv\_t$$ * $$rw\_t$$：**t到t+1**所有候选impression的总value，$$r w\_t=\sum\_{n=0}^{N\_t} x\_{n\_t} v\_{n\_t}$$ * RTG（return to go） $$r\_t$$：现在**到未来**的总收益，$$r\_t=\sum\_{t^{\prime}=t}^T r w\_{t^{\prime}}$$ #### GAVE ![](/files/mRVgSl5vlNFKVMdU8XRr) 预测如下4个值： * 当前时刻的action：$$\hat{a}\_t$$ * 当前时刻的探索系数：$$\hat{\beta}\_{t}$$，其实是就是在$$a\_t$$前面乘一个$$\beta$$得到$$\tilde{a}\_t=\hat{\beta}\_t a\_t$$，然后约束一下$$\beta$$的范围在0.5到1.5之间（sigmoid(x)+0.5就行）可以减轻OOD(Out-of-Distribution)问题。 假设$$\tilde{r}*{t+1}$$是$$\tilde{a}*{t+1}$$的RTG，而$$\hat{r}*{t+1}$$是$$a\_t$$的RTG，定义了如下的w（即$$\tilde{r}*{t+1}$$比$$\hat{r}\_{t+1}$$大的概率） $$ \left{\begin{array}{l} \left.\left.\tilde{r}*{t+1}=\operatorname{GAVE}\left(r*{t-M}, s\_{t-M}, a\_{t-M}, \ldots, r\_t, s\_t, \tilde{a}*t\right)\right)\right) \\ w\_t=\operatorname{Sigmoid}\left(\alpha\_r \cdot\left(\tilde{r}*{t+1}-\hat{r}\_{t+1}\right)\right) \end{array}\right. $$ 此外，还加了如下的辅助损失，其中$$w'$$和$$\tilde{a}'$$表示的是不更新梯度的$$w$$和$$\tilde{a}$$。第一个$$L\_r$$让$$\hat{r}*{t+1}$$接近真实值，第二个$$L\_a$$表示如果$$w\_t>0.5$$，即$$\tilde{r}*{t+1}$$比$$\hat{r}\_{t+1}$$大得比较多，第二项占主导，即让预测的action去你和探索的action $$\tilde{a}\_t'$$，反之让预测的action去你和实际的action $$a\_t$$ $$ \left{\begin{array}{l} L\_r=\frac{1}{M+1} \sum\_{t-M}^t\left(\hat{r}*{t+1}-r*{t+1}\right)^2 \\ L\_a=\frac{1}{M+1} \sum\_{t-M}^t\left(\left(1-w\_t^{\prime}\right) \cdot\left(\hat{a}\_t-a\_t\right)^2+w\_t^{\prime} \cdot\left(\hat{a}\_t-\tilde{a}\_t^{\prime}\right)^2\right) \end{array}\right. $$ * 下一时刻的RTG值：$$\hat{r}\_{t+1}$$，其实就是把CPA的约束加到RTG的计算里来： $$ \left{\begin{array}{l} C P A\_t=\frac{\sum\_i^{I\_t} x\_i c\_i}{\sum\_i^{I\_t} x\_i v\_i} \\ \mathbb{P}\left(C P A\_t ; C\right)=\min \left{\left(\frac{C}{C P A\_t}\right)^\gamma, 1\right} \\ S\_t=\mathbb{P}\left(C P A\_t ; C\right) \cdot \sum\_i^{I\_t} x\_i v\_i \\ r\_t=S\_T-S\_{t-1} \end{array}\right. $$ * 下一时刻的价值分：$$\hat{V}\_{t+1}$$ 目标是如何高效探索，用了一个expectile regression(IQL里的思想，[Offline Reinforcement Learning with Implicit Q-Learning](https://arxiv.org/abs/2110.06169))，如下，其中$$L\_2^\tau(y-m(x))$$是一个loss函数，用模型$$m(x)$$来预测$$y$$的分位数$$\tau \in (0,1)$$，$$\tau=0.85$$就是让预估价值$$\hat{V}*{t+1}$$去预测top百分之85的reward $$r*{t+1}$$ $$ \begin{aligned} L\_e & =\frac{1}{M+1} \sum\_{t-M}^t\left(L\_2^\tau\left(r\_{t+1}-\hat{V}*{t+1}\right)\right) \\ & =\frac{1}{M+1} \sum*{t-M}^t\left(\left|\tau-\mathbb{1}\left(\left(r\_{t+1}-\hat{V}*{t+1}\right)<0\right)\right|\left(r*{t+1}-\hat{V}\_{t+1}\right)^2\right) \end{aligned} $$ 而对于探索的reward $$\tilde{r}*{t+1}$$来讲，则不更新价值的梯度，即$$\hat{V}*{t+1}^{\prime}$$，只需要约束reward在价值附近就行 $$ L\_v=\frac{1}{M+1} \sum\_{t-M}^t\left(\tilde{r}*{t+1}-\hat{V}*{t+1}^{\prime}\right)^2 $$ ### 生成式出价：快手的CBD [Generative Auto-Bidding in Large-Scale Competitive Auctions via Diffusion Completer-Aligner](https://arxiv.org/pdf/2509.03348) ### 生成式出价：美团的GRAD [Generative Large-Scale Pre-trained Models for Automated Ad Bidding Optimization](https://arxiv.org/pdf/2508.02002) ## LLM+推荐小结 ### 输入ID/SID | 论文 | 公司 | 关键词 | 做法 | | --------------------------------------------- | ------ | ------------------ | ----------------------------------------------------------------------------------------------------------- | | [TIGER](https://arxiv.org/pdf/2305.05065.pdf) | google | semantic\_id粒度的生成式 |

- 基于RQ-VAE聚类
- 输入semantic\_id list，预测下一个semantic\_id

| | [HSTU](https://arxiv.org/pdf/2402.17152.pdf) | meta | item\_id粒度的生成式 |

- 性别年龄等profile特征、action type也可以作为特殊的item\_id
- 输入item\_id list，预测下一个item\_id
- 一种范式可以同时支持召回和排序

| | [COBRA](https://arxiv.org/abs/2503.02453) | 百度 | semantic\_id粒度的生成式 |

- 和TIGER类似，只是给RQ-VAE再加一个由bert的CLS得到的emb
- 在线infer更复杂

| | [HeteroRec](https://arxiv.org/pdf/2503.01469) | 阿里 | 多模态+id生成 |

- img/txt/id一起输入
- listwise multi-step prediction

| ### 输入文本 * FFT：full finetuning * PT：prompt tuning * LAT：layerwise adapter tuning * OT：option tuning * T-FEW：few-shot peft 看着落地的 | 论文 | 公司 | 关键词 | 做法 | ab收益 | tune方式 | | ----------------------------------------- | -- | -------------------- | --------------------------------------------------------------------------------------------------------------------------- | ----------- | -------- | | [KAR](https://arxiv.org/pdf/2306.10933) | 华为 | item llm+user llm |

- 让LLM总结item得到item emb；
- 让LLM总结user历史得到user emb
- 两个emb过一个mmoe做融合得到新的两个emb，给推荐模型用

| 音乐推荐 涨了播放量 | frozen | | [BAHE](https://arxiv.org/pdf/2403.19347) | 蚂蚁 | 预先计算原子用户行为 |

- LLMs的预训练浅层提取来原子用户行为的emb，并存进离线db
- 从db里查出来，和item一起过LLMs的更深层可训练层

| 广告ctr+cpm | FFT上层LLM | | [LEARN](https://arxiv.org/pdf/2405.03988) | 快手 | ItemLLM+user decoder |

- item LLM固定，输入item特征得到item emb；
- 输入item emb过user的12层trans算dense all-action loss，
- 线上推荐模型里加user emb和item emb

| 广告cvr+收入 | frozen | | [BEQUE](https://arxiv.org/pdf/2311.03758) | 阿里 | SFT+离线模拟+PRO | query重写任务，SFT得到一个LLM，将其预测的若干个候选rewrites通过offline system的feedback得到排序，再通过PRO算法再tune LLM | 电商搜索，gmv+单量 | FFT | 看着没落地的 | 论文 | 公司 | 关键词 | 做法 | tune方式 | | ------------------------------------------------- | ------ | --------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------ | | [SLIM](https://arxiv.org/pdf/2403.04260) | 蚂蚁 | 蒸馏推荐理由 |

- 输入用户行为历史，大LLM(gpt)产出的推荐理由；
- 小llm(llama2)去蒸馏这个理由拿小llm去给出全量user的推荐理由，
- 通过BERT得到emb，给推荐模型用

| FFT | | [DLLM2Rec](https://arxiv.org/pdf/2405.00338v1) | OPPO | 蒸馏推荐理由 | 在SLMI的基础上设计了ranking蒸馏和embed蒸馏 | FFT | | [LLM-CF](https://arxiv.org/pdf/2403.17688) | 快手 | 基于CoT数据集做RAG |

- 拿推荐数据对llama2做sft，再用CoT的prompt让llama2对user+item+label产出一个推理过程，并通过bge得到emb，构建一个CoT数据集。
- 在线拿当前用户+item的特征从这个数据集里ann出k个cot example的emb，和其他特征一起输入一个decoder，输出给推荐模型的sharebottom，额外加了一个CoT emb的重建loss

| FFT | | [ILM](https://arxiv.org/pdf/2406.02844) | google | 2阶段训练+q-former |

- phase1：表示学习，交替训练两类表示学习（item-text表示学习，item-item表示学习）
- phase2：item-language model训练

| frozen | | [EmbSum](https://www.arxiv.org/pdf/2405.11441) | meta | LLM摘要+t5 encoder |

- 行为历史丢给LLM产出摘要，对应的hidden states给decoder自回归;
- 历史item过t5 encoder并concat过poly；
- item过t5 encoder过poly；

| frozen | | [Agent4Ranking](https://arxiv.org/pdf/2312.15450) | 百度 | agent rewrite+ bert ranking | query重写任务，多个人群当成多个agent，每个通过多轮对话产出一个rewrite，再合在一起经过bert+mmoe计算robust损失+accuracy损失。 | frozen | 纯学术界 | 论文 | 关键词 | 做法 | tune方式 | | ------------------------------------------------- | -------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------- | | [CUP](https://arxiv.org/pdf/2311.01314) | LLM总结+bert双塔 | 把用户的一堆历史评论扔给chatgpt，让它总结出128个token，然后丢给双塔bert，另一个塔是item的描述，freeze bert底层，只tune上层 | last layer FT | | [LLaMA-E](https://arxiv.org/pdf/2308.04913) | gpt扩展instruct | instruction formulating为写300个种子指令，让gpt作为teacher，对300个种子指令进行扩展，并由领域专家评估后，去重并保证质量，得到120k个指令作为训练集，再用lora去instruct tuning | lora | | [EcomGPT](https://arxiv.org/pdf/2308.06966v1) | 一系列电商任务FFT BLOOMZ | 设置一系列的task(100多个task)来finetune BLOOMZ，包括命名实体识别、描述生成、对话intent提取等 | FFT | | [Llama4rec](https://arxiv.org/pdf/2401.13870) | prompt增强+数据增强，finetune |

- prompt增强：在prompt里引入推荐模型的信息；
- 数据增强：通过LLM给推荐模型增加样本
- adaptive aggregation：llm和推荐模型各自打分并用融合公式融合

| FFT | | [SAGCN](https://arxiv.org/pdf/2312.16275) | 分aspect打标、构图+gcn |

- LLM为用户评论打标，确定aspect；
- 分aspect构建u-i图，并gcn

| frozen | | [GReaT](https://arxiv.org/pdf/2210.06280) | 表格型数据+LLM | 随机交换属性生成数据，finetune LLM预测属性 | FFT | | [ONCE](https://arxiv.org/pdf/2305.06566) | 闭源LLM总结、开源LLM做encoder，u-i学ctr | 闭源LLM输出文本（user profiler、content summarizer、personalized content generator），给开源LLM得到user表示，item过开源LLM得到item表示，二者内积学ctr | lora训开源，frozen闭源 | | [Agent4Rec](https://arxiv.org/pdf/2310.10108.pdf) | 多智能体系统模拟交互，产出推荐样本 | 先训一个推荐模型，然后构建一个多智能体系统，模拟和这个推荐模型交互，产出新的样本给推荐模型做数据增强 | 仅训推荐模型，LLM frozen | | [RecPrompt](https://arxiv.org/pdf/2312.10463) | 两个LLM迭代出最佳prompt | 给一个初始prompt，让LLM1得到推荐结果，拿一个monitor衡量这个结果和ground truth的mrr/ndcg，再用另一个LLM产出更好的prompt给第一个LLM用，如此迭代，得到一个best prompt | frozen | | [PO4ISR](https://arxiv.org/pdf/2312.07552) | 反思原因并refine/augment地迭代出最优的prompt | 给初始prompt，收集error case让模型反思原因并refine出新的prompt，再augment出另一个prompt，并UCB选出最好的prompt，如此迭代 | frozen | | [TransRec](https://arxiv.org/pdf/2310.06491) | 受限生成 |

- 将一个item表示成3部分：id+title+attr，设计三种对应的instruct-tuning任务；
- 引入一个特殊的数据结构（FM-index），并进行constrained beam search，让模型能生成候选集中的id/title/attr，
再遍历全库候选，看不同facet的相似度（会考虑高热打压），加权融合出一个排序

| lora | | [E4SRec](https://arxiv.org/pdf/2312.02443) | 推荐id emb输入LLM | 推荐的id emb、prompt的emb一起输入LLM，最后一个词映射回推荐id emb的dim，去softmax | lora | ### 其他套路 工业界 | 论文 | 公司 | 关键词 | 做法 | | ---------------------------------------- | ---- | ----- | ------------------------------------------------------------ | | [ExFM](https://arxiv.org/abs/2502.17494) | Meta | 两阶段蒸馏 |

- 先训好teacher，并利用等待时间窗口为student数据集进行预估
- 加了一些蒸馏loss

| 学术界 | 论文 | 关键词 | 做法 | | -------------------------------------------------- | ----- | ------------------------------------ | | [SLMRec](https://openreview.net/pdf?id=G4wARwjF8M) | 一阶段蒸馏 | teacher和student都拆成多个block，每个block间蒸馏 | ### 讨论 我想输入用户历史行为，通过llm产出用户向量（64维的向量），这个向量可以是历史的总结，也可以是预测未来的一些什么东西，最终用在推荐系统的精排模型里，业界有什么好的方法吗 让gpt帮忙深度研究了一下：[版本1](https://chatgpt.com/s/dr_6821e54479dc81918c5e4bd61d645894)，[版本2](https://chatgpt.com/s/dr_6821fecfde088191b56c1ed19a3ee999)， 导出了对应的[pdf1](https://github.com/daiwk/collections/blob/master/assets/llm-gen-user-emb.pdf)，[pdf2](https://github.com/daiwk/collections/blob/master/assets/llm-gen-user-emb-64dim.pdf) ## LLM embedding ### 如何选合适的emb模型 MTEB(Massive Text Embedding Benchmark)提供了评分体系。把模型放在各种任务上测试，包括分类、聚类、检索、排序和语义相似度等，还会给不同领域单独打分。法律、医学、代码、化学这些领域都有自己的分数。 ### Gecko [谷歌DeepMind发布Gecko：专攻检索，与大7倍模型相抗衡](https://mp.weixin.qq.com/s/5e_Py_Xm0RsmP1YMcikpaQ) [Gecko: Versatile Text Embeddings Distilled from Large Language Models](https://arxiv.org/pdf/2403.20327.pdf) ![gecko](/files/1JzN3gDxmgJRCxVbpwdf) 主要包括两阶段： * pre-finetuning：类似[Large dual encoders are generalizable retrievers](https://arxiv.org/pdf/2112.07899)，自监督 * finetuning：2-step llm distillation，提出了一个FRet数据集（Few-shot Prompted Retrieval dataset） #### Pre-finetuning 2个数据集： * 大型社区qa数据集：[Large dual encoders are generalizable retrievers](https://arxiv.org/pdf/2112.07899)中的来自网上论坛和qa网站的问答pair对 * 去各种网站上爬了title-body的pair对，因为[Text Embeddings by Weakly-Supervised Contrastive Pre-training](https://arxiv.org/pdf/2212.03533)发现这种自然出现的pair对对于pre-finetuning embedding模型很有用 pre-finetuning的目标是让模型看到大量的多样性语料，对于一个预训练的语言模型$$\mathcal{M}$$，长度为$$n$$的句子对应的contextual向量$$\mathbf{W} \in \mathbb{R}^{n \times d}$$，对于任务特征$$t$$，数据集$$\mathcal{D}*{\text {pre }}=\left{\left(q\_i, p\_i\right)\right}*{i=1}^N$$，得到的向量如下： $$ \begin{aligned} \mathbf{q}*i & =\text { mean\_pool }*{|t|+\left|q\_i\right|}\left\[\mathcal{M}\left(t \oplus q\_i\right) \in \mathbb{R}^{\left(|t|+\left|q\_i\right|\right) \times d}\right] \in \mathbb{R}^d \\ \mathbf{p}*i & =\text { mean\_pool }*{\left|p\_i\right|}\left\[\mathcal{M}\left(p\_i\right) \in \mathbb{R}^{\left|p\_i\right| \times d}\right] \in \mathbb{R}^d \end{aligned} $$ 对于batchsize为$$B$$的样本来说，inbatch负例，$$\operatorname{sim}(\mathbf{x}, \mathbf{y})=\frac{\mathbf{x}^{\top} \mathbf{y}}{|\mathbf{x}| \cdot \cdot|\mathbf{y}|}$$，其loss如下： $$ \mathcal{L}*{\text {pre }}=\frac{1}{B} \sum*{i=1}^B\left\[-\log \frac{e^{\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{p}*i\right) / \tau}}{\sum*{j=1}^B e^{\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{p}\_j\right) / \tau}}\right] $$ 在这个阶段没有用hard负例，用了能适配设备的最大batchsize，这是[Towards General Text Embeddings with Multi-stage Contrastive Learning](https://arxiv.org/pdf/2308.03281)和[Text embeddings by weakly-supervised contrastive pre-training](https://arxiv.org/pdf/2212.03533)里的经验。 #### FRet ![fret](/files/Z1seLO8ANjfy92ew28Je) **LLM-based Diverse Query Generation** 从web语料$$\text { C }$$中抽出一个段落$$p\_{\text {seed }}$$，$$\mathbb{P}\_{\mathrm{QG}}$$是一个固定的few-shot的prompt，让LLM生成任务描述和这个task的query $$ \operatorname{LLM}\left(\mathbb{P}*{\mathrm{QG}}, p*{\text {seed }}\right) \rightarrow(t, q) $$ 生成的任务t例如： * question answering：`Given a query, find a passage that has the answer to the query` * fact checking：`Given a query, find a passage that allows you to check whether the query is true or not` 为了保证多样性： * 网页库本身就有很多的topic和很多的写作风格 * 在prompt里加多样的任务描述，来让模型生成的query保证多样性。 **LLM-based Positive and Negative Mining** 对于某个query $$q$$，之前的工作一般会直接把输入的段落$$p\_{\text {seed }}$$当成正样本，但实践中发现$$p\_{\text {seed }}$$一般比较长，而生成的query一般只关注其中一小部分，所以可能在整个语料库中有比$$p\_{\text {seed }}$$更准确的答案。因此，通过如下方法构造了一个FRet数据集： * 先把$$p\_{\text {seed }}$$当成正样本，in-batch负例训一个embedding模型。 * 用这个模型从文档库中检索出top N的相似段落$$P=\left{p^{(1)}, \ldots, p^{(N)}\right}$$ * 用生成query的LLM给这N个文档排序，有两种排序方法： * query likelihood：参考[Improving passage retrieval with zero-shot question generation](https://arxiv.org/pdf/2204.07496)，给定段落$$p$$，衡量query $$q$$的likelihood，$$\mathrm{QL}(q, p)=\operatorname{LLM}\left(q \mid p, \mathbb{P}\_{\mathrm{QL}}\right)$$，其中的prompt参考[PaRaDe: Passage Ranking using Demonstrations with Large Language Models](https://arxiv.org/pdf/2310.14408)包括了判断query likelihood的指令，以及一些相关query+段落的few-shot。基本思想是：**如果q和p高度相关，那么从p生成q的概率应该很高**。 * relevance classification：参考[Beyond yes and no: Improving zero-shot llm rankers via scoring fine-grained relevance labels](https://arxiv.org/pdf/2310.14122)，给定query $$q$$和段落$$p$$后，衡量特定相关性label的log likelihood：$$\operatorname{RC}(q, p)=\operatorname{LLM}\left(\text { label } \mid q, p, \mathbb{P}\_{\mathrm{RC}}\right)$$。基本思想是：**让LLM直接判断q和p的相关程度,并输出一个相关性标签**。 * 通过标准的Reciprocal Rank Fusion（RRF，倒数融合，[Reciprocal rank fusion outperforms condorcet and individual rank learning methods](https://plg.uwaterloo.ca/~gvcormac/cormacksigir09-rrf.pdf)）方法得到rank函数，对上面两个方法的排序结果merge：$$R(q, p)=1 / r\_{\mathrm{QL}}(q, p)+1 / r\_{\mathrm{RC}}(q, p)$$...其实就是rankindex * 基于得分筛选样本： * 正样本：$$p^{+}=\underset{p \in P}{\arg \max } R(q, p)=p\_1$$ * hard负例：排名第$$N$$位的样本$$p\_N$$，也可以从除了第1个外的N-1个里随机sample #### Unified Fine-tuning Mixture 除了FRet，还融合了多个公开数据集： * Natural Questions：[Natural Questions: A Benchmark for Question Answering Research](https://aclanthology.org/Q19-1026.pdf) * HotpotQA：[Hotpotqa: A dataset for diverse, explainable multi-hop question answering](https://arxiv.org/pdf/1809.09600) * FEVER：[Fever: a large-scale dataset for fact extraction and verification](https://arxiv.org/pdf/1803.05355) * MedMCQA：[Medmcqa: A large-scale multi-subject multi-choice dataset for medical domain question answering](https://arxiv.org/pdf/2203.14371) * SNLI：[A large annotated corpus for learning natural language inference](https://arxiv.org/pdf/1508.05326) * MNLI：[A broad-coverage challenge corpus for sentence understanding through inference](https://arxiv.org/pdf/1704.05426) * MIRACL：多语言的数据集[Miracl: A multilingual retrieval dataset covering 18 diverse languages](https://direct.mit.edu/tacl/article/doi/10.1162/tacl_a_00595/117438/MIRACL-A-Multilingual-Retrieval-Dataset-Covering) * huggingface上的一些分类数据集 将这些数据集处理成一个统一的格式，发现不同的任务对prompt的格式敏感程度不同，，非对称任务（如BEIR）对格式更敏感，而对称任务的性能相对稳定。 * 对称格式（Symmetric Formatting）：输入和目标使用相同的格式。 * 输入：task: {task} | query: {input} * 目标：task: {task} | query: {target} * 非对称格式（Asymmetric Formatting）：输入和目标使用不同的格式。 * 输入：task: {task} | query: {input} * 目标：title: {title} | text: {target} 参考[One Embedder, Any Task: Instruction-Finetuned Text Embeddings](https://aclanthology.org/2023.findings-acl.71.pdf)，对于每个文本$$x$$，找到另一个同样label是$$y$$的样本当成正样本$$x^{+}$$，随机找一个label不是$$y$$的当作负样本$$x^{-}$$。 实践中，在一个batch中，同一个$$x^+$$可能出现overlap，会造成in-batch negatives中的false negative问题。参考[poe的回复](https://poe.com/s/XHJyRAAOc9ZAuQu5yz2p)，即同一个mini-batch中假设有(x1, x1+, x1-) 和 (x2, x2+, x2-)，可能出现x1+ 与 x2 或 x2+ 相同或非常相似的情况。那么： * 对于x1来说，x1+是正例。 * 但是如果x1+ 与 x2 相同或非常相似，模型可能会错误地认为x1+应该与x2区分开来，因为x2是另一个样本的输入。 * 或者如果x1+ 与 x2+ 相同或非常相似，模型可能会混淆应该如何处理这个重叠的样本。 因为在理想情况下，x1+应该只是x1的正例，而不应该被视为任何其他样本的负例。但由于重叠，模型可能错误地将x1+视为x2或其他样本的负例。解决方法，给每个三元组分配唯一的id，让模型专注于在给定x的情况下，区分x+和x-。 有$$M$$个数据集$$\left\[\mathcal{D}^{(1)}, \ldots, \mathcal{D}^{(M)}\right]$$，每个数据集是$$\mathcal{D}^{(m)}=\left{\left(t\_i, q\_i, p\_i^{+}, p\_i^{-}\right)\right}\_{i=1}^N$$，$$t$$是任务描述，给定一个batch\_size=B的batch，同batch里的其他query可以看成[SamToNe: Improving Contrastive Loss for Dual Encoder Retrieval Models with Same Tower Negatives](https://arxiv.org/pdf/2306.02516)中说的same-tower negative（对同模态的效果比较好，例如这边都是query）： $$ \mathcal{L}*{\text {main }}=\frac{1}{B} \sum*{i=1}^B\left\[-\log \frac{e^{\operatorname{sim}\left(\mathbf{q}\_i \mathbf{p}*i^{+}\right) / \tau}}{\sum*{j=1}^B\left(e^{\operatorname{sim}\left(\mathbf{q}\_i \mathbf{p}*j^{+}\right) / \tau}+\mathbb{1}*{\[j \neq i]} e^{\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{q}\_j\right) / \tau}\right)+e^{\operatorname{sim}\left(\mathbf{q}\_i \mathbf{P}\_i^{-}\right) / \tau}}\right] $$ 同时还参考[Matryoshka representation learning](https://arxiv.org/pdf/2205.13147)的俄罗斯套娃加了一个MRL的loss，让模型适配不同的dim，gecko是768和256的dim ### ChatRetriever [ChatRetriever: Adapting Large Language Models for Generalized and Robust Conversational Dense Retrieval](https://arxiv.org/pdf/2404.13556v1) 思想：原来输入的prompt是x，输出的response是y，添加t个特殊的`[emb_i]` token，输入 $$ s=\[x\_1, \ldots, x\_N,\left\[\mathrm{EMB}\_1\right], \ldots,\left\[\mathrm{EMB}\_t\right], y\_1^{+}\ldots, y\_M^{+},\left\[\mathrm{EMB}\_1\right], \ldots,\left\[\mathrm{EMB}\_t\right]] $$ 然后训练的时候，每个生成的$$y\_i$$只看得到它前面的y，还有x后面的那t个特殊token： $$ \mathcal{L}*{\mathrm{S}}=-\frac{1}{M} \sum*{i=1}^M \log p\left(y\_i^{+} \mid y\_1^{+}, \ldots, y\_{i-1}^{+}, \mathbf{x}\_{1: t}\right) $$ ![chatretriever](/files/cywJtkm6p6rsWxJWwCmf) 对应的[代码](https://github.com/kyriemao/ChatRetriever/blob/cbcd9b10f7d0e1dc27ae299f463a5d27e423fca7/src/kindred/models/model_utils.py#L247) ```python def unified_model_forward(model, model_type: str, inputs: dict, normalize_emb: bool): inputs.pop("sample_ids", None) inputs.pop("input_texts", None) if model_type in ['bge', 'llm_embedder']: output = model(**inputs) embs = output.last_hidden_state[:, 0] elif model_type in set(['qwen', 'qwen_chat', 'qwen_chat_cot', 'qwen_chat_lora', 'qwen_chat_lora_eval', 'qwen_chat_cot_lora', 'qwen_chat_cot_lora_eval', 'qwen15_chat_cot_lora_eval', 'repllama', 'llama', 'repllama-train', 'repllama_v2', 'repllama_v2-train', 'repllama_v2-continue_train', 'repllama_chat', 'repllama_chat-train', 'repllama_chat_cot', 'repllama_chat_cot-train', 'mistrial_cot-train', 'mistrial_chat_cot-train', 'mistrial_cot', 'mistrial_chat_cot', 'qwen15', 'qwen15_chat', 'qwen15_chat_lora', 'qwen15_chat_cot_lora', 'qwen15_chat_cot']): inputs['output_hidden_states'] = True output = model(**inputs) hidden_states = output.hidden_states[-1] last_token_indices = inputs['attention_mask'].sum(dim=1) - 1 embs = hidden_states[torch.arange(hidden_states.size(0)), last_token_indices] elif model_type in ['e5_mistrial', 'e5_mistrial-train']: outputs = model(**inputs) embs = last_token_pool(outputs.last_hidden_state, inputs['attention_mask']) elif model_type in ['ance', 'gtr', 'splade']: embs = model(**inputs) elif model_type in ['bert']: output = model(**inputs) embs = output.pooler_output else: raise NotImplementedError("Model type {} is not supported now.".format(model_type)) if normalize_emb: embs = torch.nn.functional.normalize(embs, p=2, dim=-1) return embs ``` ### Instructor [One Embedder, Any Task: Instruction-Finetuned Text Embeddings](https://aclanthology.org/2023.findings-acl.71.pdf) 基于google的GTR(Generalizable T5-based dense Retrievers)模型（[Large Dual Encoders Are Generalizable Retrievers](https://arxiv.org/pdf/2112.07899)）加了task instruction，用对比学习loss训练 ### LLM-Embedder(BGE) [Retrieve Anything To Augment Large Language Models](https://arxiv.org/pdf/2310.07554)和[C-Pack: Packed Resources For General Chinese Embeddings](https://arxiv.org/pdf/2309.07597)这两个对应的是一样的代码 ### RepLLaMA [Fine-Tuning LLaMA for Multi-Stage Text Retrieval](https://arxiv.org/pdf/2310.08319) ### E5\_mistral-7b [Improving Text Embeddings with Large Language Models](https://arxiv.org/pdf/2401.00368) ### GRIT [Generative Representational Instruction Tuning](https://arxiv.org/pdf/2402.09906) ### LLM2Vec [LLM2Vec: Large Language Models Are Secretly Powerful Text Encoders](https://arxiv.org/pdf/2404.05961) 由3步组成： * Bi-directional：把causal mask干掉，改成全1mask * 引入masked next token predtion任务：类似mlm，mask掉中间的词，拿周围的词预测 * 对比学习simcse：前两步让模型有了bi-directional的能力，把所有词的emb通过pooling（实验表明mean pooling最有效）得到句子表示，同一句话里mask掉几个词的为正例，不同句子为负例，对比学习 ### SyCL [Beyond Contrastive Learning: Synthetic Data Enables List-wise Training with Multiple Levels of Relevance](https://arxiv.org/pdf/2503.23239) 用LLM生成具有多个相关性级别的**合成**文档，结合列表式损失函数（Wasserstein距离），提升检索器的排名性能。 传统的密集检索器训练依赖对比学习和二元相关性标签（InfoNCE损失），即将文档分为正样本和负样本。这种方法存在两个主要局限： * 忽略细微相关性差异：除了明确标注为相关的文档外，所有其他文档被同等视为负样本，无法反映实际的相关性程度。 * 对噪声敏感：二元标签无法充分利用数据的排名信息，且易受标注错误影响。 具体方法： * 多级排名上下文生成：使用 MS MARCO 数据集的查询，提示LLM生成四篇不同相关性级别的合成文档。通过顺序生成确保相关性逐步降低，并使用随机采样（如句子长度和难度）增加多样性。分配标签：{3, 2, 1, 0}，分别对应完美相关到无关。 * Wasserstein 距离损失：不同于InfoNCE的逐对比较，Wasserstein 距离考虑整个文档集合的相关性分布。通过比较真实标签分布与预测得分分布，优化模型以更准确地排名文档。 ### RARE [腾讯搜索广告生成式检索](https://mp.weixin.qq.com/s/zRGuttbqKkTFasg9AY4fGA) [Real-time Ad retrieval via LLM-generative Commercial Intention for Sponsored Search Advertising](https://arxiv.org/pdf/2504.01304) ### BGE-code/VL [代码、多模态检索全面登顶SOTA！智源BGE向量模型三连击，并全面开放](https://mp.weixin.qq.com/s/DYGix_6Zf7M50aC8TtpQKg) * BGE-code：[Towards A Generalist Code Embedding Model Based On Massive Data Synthesis](https://arxiv.org/abs/2505.12697) * BGE-VL：[MegaPairs: Massive Data Synthesis For Universal Multimodal Retrieval](https://arxiv.org/abs/2412.14475) * BGE-VL-screenshot：[Any Information Is Just Worth One Single Screenshot: Unifying Search With Visualized Information Retrieval](https://arxiv.org/abs/2502.11431) ### UniME [Breaking the Modality Barrier: Universal Embedding Learning with Multimodal LLMs](https://arxiv.org/pdf/2504.17432) #### 阶段一：文本判别知识蒸馏 ![](/files/5ts8PkXSpkYQkY6e7D02) 用纯文本数据来增强MLLM中LLM的嵌入能力，用了273k个句子对。 * teacher：基于LLM的嵌入模型NV-Embed V2（对比训练中移除了causal mask）离线批量产出文本的emb * student：MLLM中把LLM部分剥离出来，输入prompt `Summary the above sentences in one word: \n”`，最后一个token的emb当成输出 * 蒸馏：teacher和student间算KL散度，LoRA训练 推理时： * 单模态输入：通过prompt的设置，决定只走对应的vision/text encoder * 图片+文字输入：通过prompt，各自过模型，然后把输出的2个emb进行融合 #### 阶段二：困难负样本增强指令微调 ![](/files/CVgxankC7k1or3EUyowN) 拿多模态的样本对来提升图文之间的对齐，用了662k个pair对： * query: img+prompt * doc: img 样本处理： * 干掉false negative：有些负样本和query的相似度太高了，干掉 * 增加hard negative：除了正例和前面的false negative外，在负样本里找出k个和query最像的，当成hard negative loss是infoNCE，然后用QLoRA来微调 代码： ```python import torch from PIL import Image from torch.nn import functional as F from self_evaluate.utils.utils import init_model_and_transform model_name = "phi35V" base_model_path="DeepGlint-AI/UniME-Phi3.5-V-4.2B" if model_name == "phi35V": img_prompt = '<|user|>\n<|image_1|>\nSummary above image in one word: <|end|>\n<|assistant|>\n' text_prompt = '<|user|>\n\nSummary above sentence in one word: <|end|>\n<|assistant|>\n' elif model_name == "llava_16": img_prompt = "[INST] \nSummary above image in one word: [/INST]" text_prompt = "[INST] \nSummary above sentence in one word: [/INST]" text = "A man is crossing the street with a red car parked nearby." image_path = "figures/demo.png" input_texts = text_prompt.replace('', text) input_image_prompt = img_prompt input_image = [Image.open(image_path)] model, transform = init_model_and_transform(model_name, base_model_path) inputs_text = transform(text=input_texts, images=None, return_tensors="pt", padding=True) for key in inputs_text: inputs_text[key] = inputs_text[key].to("cuda") inputs_image = transform(text=input_image_prompt, images=input_image, return_tensors="pt", padding=True).to("cuda") with torch.no_grad(): emb_text = model(**inputs_text, output_hidden_states=True, return_dict=True).hidden_states[-1][:, -1, :] emb_image = model(**inputs_image, output_hidden_states=True, return_dict=True).hidden_states[-1][:, -1, :] emb_text = F.normalize(emb_text, dim=-1) emb_image = F.normalize(emb_image, dim=-1) Score = emb_image @ emb_text.T print("Score: ", Score) # Score: 0.59 ``` 其中： ```python def init_model_and_transform(model_name, base_model_path): if model_name == 'phi35V': transform = AutoProcessor.from_pretrained("microsoft/Phi-3.5-vision-instruct", trust_remote_code=True) model = AutoModelForCausalLM.from_pretrained(base_model_path, device_map="cuda", trust_remote_code=True, torch_dtype=torch.float16, _attn_implementation='flash_attention_2') elif model_name == "llava_16": transform = LlavaNextProcessor.from_pretrained("llava-hf/llava-v1.6-mistral-7b-hf") model = LlavaNextForConditionalGeneration.\ from_pretrained(base_model_path, device_map="cuda", torch_dtype=torch.float16, low_cpu_mem_usage=True) transform.tokenizer.padding_side = "left" transform.tokenizer.padding = True return model, transform ``` ### Qwen3-emb [Qwen3 Embedding: Advancing Text Embedding and Reranking Through Foundation Models](https://arxiv.org/pdf/2506.05176) #### 架构 ![](/files/mgHT2GUtRkXT6d7hc796) * emb模型： * query：输入instruction+query，拿eos对应的emb作为输出 * doc：不用instrunction，直接输入doc，拿eos对应的emb作为输出 * rerank模型：输入instruction+query和doc，拿如下prompt的输出经过lm head输出yes/no的概率（是否匹配） ``` <|im_start|>system Judge whether the Document meets the requirements based on the Query and the Instruct provided. Note that the answer can only be "yes" or "no".<|im_end|> <|im_start|>user : {Instruction} : {Query} : {Document}<|im_end|> <|im_start|>assistant \n\n\n\n ``` #### 合成数据 数据：多样性，包括多语言、跨语言、多领域、多任务、长/短文本、代码检索 数据来源： * 人工标注数据：搜索(MS MARCO)、qa、MNLI、SNLI等，大概10M * 公开领域的弱监督数据：维基百科、redit、arxiv等，大概10亿，放弃了 * 大模型合成数据：用Qwen3为每个doc生成相关问题，理论上可以构建无限数据 此外， * 根据文档，从一个比较大的角色库（比如大学生、小学生、公务员、商人等）里检索出若干个角色，用llm判断哪些角色适合这个文档，以及他们会问什么类型的问题（keyword/summary/逻辑推理），难度（大学/小学）、长度、语言，生成一个config * 拿角色+文档+config再给llm，生成真实的用户问题 * 再用一个预训练好的emb模型先进行检索，过滤掉那些比较低质的数据（例如相似度太低或者根本检索不到相关文档） #### 训练 ![](/files/XoN1LhZhLIPxQw4CU8VQ) 多阶段训练 * stage1：Large-Scale Synthetic Data-Driven Weak Supervision Training： * stage2：High-Quality Synthetic Data Utilization in Supervised Fine Tuning: 从合成数据中筛选出高质量数据，以及人工标注的高质量数据 * stage3：Model Merging: 对stage2中的多个ckpt进行merge rerank模型里stage1没啥用，直接用stage2和3，loss是sft的loss，即对yes/no去算交叉熵 embedding模型是3阶段，用一个改进的对比学习来训： $$ L\_{\text {embedding }}=-\frac{1}{N} \sum\_i^N \log \frac{e^{\left(s\left(q\_i, d\_i^{+}\right) / \tau\right)}}{Z\_i} $$ * 负例：$$K$$个hard neg $$d^{-}\_{i,k}$$、batch内的其他query $$q\_j$$、batch内的除了正负例的其他doc $$d\_j$$ * 计算负样本与query的相似度s1，正样本与query的相似度s2，如果s1比s2大超过一个阈值那就是false negative，即下面的$$m\_{ij}$$ $$ Z\_i=e^{\left(s\left(q\_i, d\_i^{+}\right) / \tau\right)}+\sum\_k^K m\_{i k} e^{\left(s\left(q\_i, d\_{i, k}^{-}\right) / \tau\right)}+\sum\_{j \neq i} m\_{i j} e^{\left(s\left(q\_i, q\_j\right) / \tau\right)}+\sum\_{j \neq i} m\_{i j} e^{\left(s\left(d\_i^{+}, d\_j\right) / \tau\right)} $$ 其中， $$ m\_{i j}= \begin{cases}0 & \text { if } s\_{i j}>s\left(q\_i, d\_i^{+}\right)+0.1 \text { or } d\_j==d\_i^{+} \ 1 & \text { otherwise, }\end{cases} $$ 训练时的策略： * 动态batchsize：训练数据长度不同，能接收的最大batchsize不同，所以对于不同长度用的bs不一样 * gradient checkpointing：将大的bs切成小的sub-bs，先计算每个sub-bs的emb，因为gradient checkpointing不保存梯度，所以这个时候可以merge，merge完后再计算梯度 * 训练的时候带了MRL loss 模型融合原理：多个ckpt，可能分别擅长不同的task，通过对模型参数的线性/球面插值，可以merge出一个对各任务都不错的模型。 参考[Improving general text embedding model: Tackling task conflict and data imbalance through model merging](https://arxiv.org/abs/2410.15035)的slerp，基于球面插值的融合方法，给定2个ckpt，分别算一下和训练前ckpt的差值，称为任务向量。然后拿这2个任务向量和原来ckpt的点构成的平面，使得少量训练数据和一个loss，算出合适的夹角和模长得到新向量，再去和其他ckpt重复这个步骤进行merge。 训练的时候用的lora，emb和rerank的hard negative设计不一样 ### gemini embedding [Gemini Embedding: Generalizable Embeddings from Gemini](https://arxiv.org/pdf/2503.07891) ### EmbeddingGemma [EmbeddingGemma: Powerful and Lightweight Text Representations](https://arxiv.org/abs/2509.20354) [解读](https://www.xiaohongshu.com/explore/68db1d3a00000000130372d4?app_platform=ios\&app_version=9.3.1\&share_from_user_hidden=true\&xsec_source=app_share\&type=normal\&xsec_token=CBL97bjctCoRqfMMLs0o7XzqpWS2lT-ucQJptp3cIpOAA=\&author_share=1\&xhsshare=WeixinSession\&shareRedId=ODY2NUg4NE82NzUyOTgwNjY0OTc1STdO\&apptime=1759251795\&share_id=5456ef75a99043fe98df53343cf96991) ![](/files/XBbGPSCu8ZQVGqDOYsV2) 模型结构： * 把gemma这种decoder only的模型改成一个encoder-decoder架构(用如上图的T5-gemma的方法，[Encoder-decoder gemma: Improving the quality-efficiency trade-off via adaptation](https://arxiv.org/abs/2504.06225))。 * 其实encoder部分和原模型是一样的，只是把mask改成双向的。在得到T个token的输出后，mean pooling（这里对比过更复杂的pooling方式，发现mean的效果最好）成一个768的emb。再过2层nn，最终映射到768。 * 模型输入是task描述+原文本，例如检索任务里，query侧是"task: search result | query: {content}"，doc侧是"title: {title | 'none'} | text: {content}" 3个loss： * 基于inbatch负例的NCE： $$ \mathcal{L}*C=\frac{1}{B} \sum*{i=1}^B\left\[-\log \frac{e^{\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{p}\_i^{+}\right) / \tau}}{w\_i e^{\operatorname{sim}\left(\mathbf{q}*i, \mathbf{p}*i^{-}\right) / \tau}+\sum*{j=1}^B \mathbb{1}*{\mathrm{TN}}(i, j) e^{\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{p}\_j^{+}\right) / \tau}}\right] $$ 其中的sim是cosine相似度，而$$\mathbb{1}\_{\mathrm{TN}}$$把重复样本里的false negatives mask掉(其实就是保留batch内其他query的正的doc，还有当前query的其他正的doc)。另外，$$w\_i=\exp \left(\alpha \operatorname{sg}\left(\operatorname{sim}\left(\mathbf{q}\_i, \mathbf{p}\_i^{-}\right)\right)\right)$$表示一个hard negative的难度，$$\alpha$$是个超参，设成5 $$ \mathbb{1}\_{\mathrm{TN}}(i, j)= \begin{cases}0 & \text { if } q\_i=q\_j \text { or } p\_i^{+}=p\_j^{+} \ 1 & \text { otherwise } .\end{cases} $$ * global orthogonal regularizer(GOR)的loss： 来自[Learning spread-out local feature descriptors](https://arxiv.org/abs/1708.06320)，可以让emb在emb空间内尽量展开，一方面对量化更鲁棒，另一方面也更方便ann检索。其实就是让随机挑选的一个pair对在统计意义上接近于从单位球面上的均匀采样，论文中衡量的是mean和二阶矩(second moment)，这里只用了二阶矩，因为发现二阶矩接近的时候，mean自然也会更接近。如下，对query间和正样本间均做了二阶矩的约束。 $$ \mathcal{L}*{\mathcal{S}}=\frac{1}{B(B-1)} \sum*{i, j \in \mathcal{B}: i \neq j}\left(\mathbf{q}\_i^{\top} \mathbf{q}*j\right)^2+\frac{1}{B(B-1)} \sum*{i, j \in \mathcal{B}: i \neq j}\left(\mathbf{p}\_i^{+\top} \mathbf{p}\_j^{+}\right)^2 $$ * embed distill loss 来自[EmbedDistill: A Geometric Knowledge Distillation for Information Retrieval](https://arxiv.org/abs/2301.12005)，看着好像就是teacher和student的emb算一下L2距离，对query间、正样本间、hard负样本间均算这个loss：$$\mathcal{L}*{\mathcal{D}}=\mathcal{L}*{\mathcal{D}}^{\mathrm{Q}}+\mathcal{L}*{\mathcal{D}}^{\mathrm{P}^{+}}+\mathcal{L}*{\mathcal{D}}^{\mathrm{P}^{-}}$$ 此外，NCE和GOR的loss也通过MRL作用到了各个子emb(512/256/128)上 训练的trick： * Encoder-Decoder Training：用如上的T5Gemma方式改成enc-dec结构，然后在gemma3的预训练数据上通过UL2（[Ul2: Unifying language learning paradigms](https://arxiv.org/abs/2205.05131)）进行预训练，然后拿这个encoder来用 * Pre-finetuning：用大量的无监督语料训练，加大batch size以充足的emb负例，并让梯度更稳定。任务覆盖了问答、句子相似度、代码检索、网络搜索等。 * Finetuning：高质量的数据，小的batchsize，加了hard negative，让batch内的样本更难。将任务分成三类：任务多样性（task diversity）、语言多样性（language diversity）、编码能力（coding capability），拿gemeni embedding工作里通过grid search找到的混合比例作为贝叶斯优化的种子，还从Dirichlet分布中随机采样10组不同的混合比例，形成多个版本的数据集（即不同任务侧重不同）。 * Model Souping：用这些数据集分别训练模型，最后再把这些模型的权重平均得到最终的模型。结果就是最终的模型泛化能力更强，在各个任务上都比单个模型表现更好。 * Quantization-Aware Training：3种类型的权重表示: int4 per-block, int8 per-block, and mixed-precision per-channel，用QAT训练 效果： * 在MTEB的多语言、英语和代码榜单上，是5亿参数以下模型里的第一名，而且是断层领先，性能甚至能和一些接近它两倍大的模型相抗衡。 * 性能在权重被量化到int4/int8，或者嵌入维度被砍到128维时，依然保持得很稳定 ## LLM+搜索 ### Pinterest的搜索相关性优化 [Improving Pinterest Search Relevance Using Large Language Models](https://arxiv.org/pdf/2410.17152) ### Google的BlockRank [Scalable In-context Ranking with Generative Models](https://arxiv.org/pdf/2510.05396) 针对ICR微调的LLM注意力中存在的固有且可利用的结构： * 文档间块稀疏性：注意力在同一文档块内密集,但在不同文档间稀疏; * 查询-文档块相关性：中间层中某些查询词与文档块之间的注意力分数与该文档的实际相关性高度相关。 BlockRank通过以下方式改进LLM的注意力操作： * 在架构上强制实现观察到的文档间块稀疏性,将注意力复杂度从二次降至线性，且不损失性能; * 在微调过程中通过辅助对比训练目标，优化真实相关文档的查询-文档块相关性，提升检索效果。 ### Linkedin的MixLM [MixLM: High-Throughput and Effective LLM Ranking via Text-Embedding Mix-Interaction](https://arxiv.org/pdf/2512.07846) ![](/files/gvEEnUxY61tw8sTFzkox) ![](/files/6uXf7cfnBMb5lEPj5kq1) ### Linkedin的Semantic Search [Semantic Search At LinkedIn](https://arxiv.org/abs/2602.07309) #### 整体架构 ![](/files/zWjGT4H3lMKzvcmH733G) prompt：prefix+context(query+用户特征)+document+suffix 相关性训练：用oracle（8B LLM）来定义和评估相关性策略，并标注出高质量数据集。训一个SLM(Small Language Model，0.6B)来预估oracle的打分 * domain reasoning蒸馏：用forward/reverse KL来蒸馏teacher的reasoning文本和打分 * soft-label微调：将oracle的打分映射到$$\[0,1]$$，再训一个2分类的yes/no概率。 * ranking loss：在list-wise数据上sft，每个query包括top-k的EBR（emb-based检索，即召回候选）文档和k个随机文档 * chat-template inference interface：chat-template里强调这是一个二分类相关性问题，包括query和紧凑的候选（title/公司/职级等），推理时取第一个yes/no的logit来用 按这个训练过程训了2个相关性模型： * 拿oracle的打分先训一个1.7B的teacher * 再训一个0.6B的student，只学teacher打分，不学oracle ![](/files/vwsIapg8zQ7AnGPzrFPL) 同样地，还拿来训了一个用户engagement的teacher，多分类（click、apply、dismiss、long-dwell、connect、follow、message等），发现人肉拍权重对权重大的task是有收益的 上面2个teacher一起，来蒸馏出SLM * 先用一个相关性slm热启，再让它去学所有techer，主要学engagement目标，对相关性加一个小的权重 * 叠加特征工程有进一步提升 ![](/files/ADFHzlMn5dAIe1ORKR5C) 还做了loss mask，即一些很sparse的正例很容易被淹没，因此对于每个正例，只保留它所在那些query的样本来做负例，如图 ![](/files/CGpAzJ70omRbLFvfDiSF) 还加了校准，即（[LiRank: Industrial Large Scale Ranking Models at LinkedIn](https://arxiv.org/pdf/2402.06859)）里的Isotonic Calibration Layer（保序回归） 特征工程： * summarization：参考[Rec-R1: Bridging Generative Large Language Models and User-Centric Recommendation Systems via Reinforcement Learning](https://arxiv.org/pdf/2503.24289)进行了RL，1.7B的actor，engagement teacher当成reward model。然后拿这个来产出用户profile的summary * 数值型特征：一些二值型特征和历史ctr这种，另外，数值型特征只保留小数点最后2位也没有损失 #### 语义召回 架构参考[LiNR: Model Based Neural Retrieval on GPUs at LinkedIn](https://arxiv.org/abs/2407.13218) 从1.3B候选里选1000条，用fine-tuned embedding models和in-GPU retrieval-asranking (RAR) distance models来对全库同时优化相关性和engagement，双塔： * infonce：用相关性label构造正负例 * 还把多个个性化特征(公式里的f)加权，直接加到q,d的cosine上：$$S(q, d)=w\_0\left\langle e\_q, e\_d\right\rangle+\sum\_{i=1}^n w\_i f\_i(q, d),$$，然后这个score同时学相关性label和engagement label：$$\mathcal{L}*{\mathrm{RAR}}=\lambda \mathcal{L}*{\mathrm{BCE}}\left(S, L\_R\right)+(1-\lambda) \mathcal{L}\_{\mathrm{BCE}}\left(S, L\_E\right)$$ serving：GPU加速的exhaustive retrieval stack（暴力全库计算），先做了一些属性过滤、然后压缩向量维度 #### 架构优化 还进行了一系列软硬件协同优化，包括结构化剪枝、离线上下文摘要压缩、文本与Embedding混合交互，以及一个专门为打分优化的、仅执行Prefill的推理栈。在固定的延迟约束下，将排序服务的吞吐量提升了75倍以上，同时保持了接近教师模型的NDCG性能。 ### 百度的Agent4Ranking [Agent4Ranking: Semantic Robust Ranking via Personalized Query Rewriting Using Multi-agent LLM](https://arxiv.org/pdf/2312.15450) ![](/files/0KcDSeFaw0DslwByNU05) 其中的rewrite模块如下，搞4个agent，模拟4个人群的人与LLM对话，最终得到符合人群特点的rewrite ![](/files/A5xAXm21qKB1NiwtSdM0) 其中的rank模块如下，是一个bert，输入原始query和4个rewrites，加上target item，MMOE，算5个query间的js散度(robust loss)，以及综合输出和label的accuracy loss ![](/files/vhRj0tCitsXBB3Y5VhuK) ### 百度的搜索广告召回 [搜索广告召回的生成式革新](https://mp.weixin.qq.com/s/q4-KJvmroyIAlDtjtRMKIw) ### 百度的AI搜索 [Towards AI Search Paradigm](https://arxiv.org/abs/2506.17188) ..63页 该采用由多个LLM驱动的智能体构成的模块化体系(Master、Planner、Executor和Writer)，能够动态适应从简单事实查询到复杂多阶段推理任务的各类信息需求。这些智能体通过动态协同的工作流程，评估查询复杂性，在Master的判断和指导下对应不同任务的特性的智能体动态组合，并针对复杂任务将问题分解为可执行的任务,并协调使用各种工具进行任务执行与内容合成。 ### 百度的RELATE [RELATE: A Reinforcement Learning-Enhanced LLM Framework for Advertising Text Generation](https://arxiv.org/pdf/2602.11780) ![](/files/SNR1gVnMxxdxOJWFusSq) 基于qwen3，参考grpo，设计了token-level和sentence-level的reward ### 美团的IterQR [IterQR: LLM-based Iterative Query Rewrite for E-commerce Search](https://arxiv.org/pdf/2504.05309) ### 美团的RTD [From Reasoning LLMs to BERT: A Two-Stage Distillation Framework for Search Relevance](https://arxiv.org/pdf/2510.11056) Reasoning-then-Distilling (RTD) ### 阿里搜索广告 [阿里妈妈搜索广告2024大模型思考与实践](https://mp.weixin.qq.com/s/hgs_BzFZdjrDSbf9d74ilA) ### 快手的OneSearch [OneSearch: A Preliminary Exploration of the Unified End-to-End Generative Framework for E-commerce Search](https://arxiv.org/pdf/2509.03236) ### 快手的OneSug [OneSug: The Unified End-to-End Generative Framework for E-commerce Query Suggestion](https://arxiv.org/pdf/2506.06913v1) prefix->query的场景 ![](/files/JJLySpKPWdkMVzk74GMT) ### 快手的GREAT 视频落地页里的搜索词推荐 [GREAT: Guiding Query Generation with a Trie for Recommending Related Search about Video at Kuaishou](https://www.arxiv.org/pdf/2507.15267) 建库：高消费价值的优质query，天级更新，构建字典树（Trie） * 训练：增加NTTP（Next-Token in Trie Prediction）任务(其实就是同层的每个节点都算下logp) * 推理： * 解码时字典树实时地引导下一个token生成 * 还引入了一个后处理模块，过滤低质量内容 ![](/files/C8Bv665QCK9fV4jcfpbJ) ### 字节的SUMMA [SUMMA: A Multimodal Large Language Model for Advertisement Summarization](https://arxiv.org/pdf/2508.20582) 搜索广告 ### 小红书的GDR [小红书搜索：生成式检索的探索与实践](https://mp.weixin.qq.com/s/yApGxCGxjWnZQu8PoO9Qeg) [Generative Dense Retrieval: Memory Can Be a Burden](https://arxiv.org/abs/2401.10487) ### LightRetriever ICLR2026，[LightRetriever: A LLM-based Text Retrieval Architecture with Extremely Faster Query Inference](https://arxiv.org/abs/2505.12260) ![](/files/PSBX5fL9bLpLNE8Ojt1B) doc侧用完整LLM，query侧（假设query有n个token）做了如下精简： * dense检索： * query的每个token分别和prompt的tokens拼一起，得到n个token序列，各自过LLM，再avg pooling得到query向量去检索。 * serving的时候可以把prompt x 词表过完LLM的emb缓存起来，直接查表 ![](/files/rtTl3zYjZIpjKU67JRNg) * sparse检索： * 没有prompt了，将query的每个token直接映射成词频，doc过完llm后的emb也映射到词表大小，然后去做对比学习。 * serving时建的是倒排索引，即key是词，value是一个doc的list，按词频之类的倒排，query也直接用词频向量表示，query每个词去查倒排对应的doc list，再merge起来 ![](/files/1AVkbiD3fWVW4k4eft2n) ## 传统推荐模型 ### Google的推荐生态系统 [Modeling Recommender Ecosystems: Research Challenges at the Intersection of Mechanism Design, Reinforcement Learning and Generative Models](https://storage.googleapis.com/gweb-research2023-media/pubtools/pdf/e00cc0ce4480c15339b7798943560ad1a0d593ce.pdf) ### Google的发现性 [Diversifying by Intent in Recommender Systems](https://arxiv.org/pdf/2405.12327)，涨了dau等指标 ### Google的item冷启 [Item-centric Exploration for Cold Start Problem](https://arxiv.org/pdf/2507.09423) 就是对冷启的item用beta分布(汤普森采样)去做ee。依据就是beta分布里的特点：采样出来的p，当展现很少的时候很大，即更偏向探索；展现比较多的时候，p接近于ctr，更偏向利用 * alpha+点击数，beta+展现未点击数去更新 * 采样的时候卡了一个阈值，如果$$p\left(\mathrm{\~S}*{+} \mid \mathrm{u}, \mathrm{i}\right)<\mu*{\mathrm{i}}-2 \sigma\_{\mathrm{i}}$$，就相当于在置信区间之外，扔掉 和meta在2023年的user-centric ranking（[Breaking the Curse of Quality Saturation with User-Centric Ranking](https://arxiv.org/pdf/2305.15333)）没啥关系 ### Google的熟悉度消偏 [Learning to Alleviate Familiarity Bias in Video Recommendation](https://arxiv.org/pdf/2602.07987) familiarity bias（熟悉度偏置）：用户因为本来就熟悉某些内容/频道/创作者，更容易给高反馈，模型再学到这种反馈后，就会继续把这些“老熟人”推得更猛，结果就是推荐越来越重复，新内容和新作者更难被看到。 挖掘一些熟悉度特征，然后用如下2种方式预估bias： * 离散/低维特征：把熟悉度特征分桶，比如“该频道历史看过0次、1–2次、3–8次……”之类，然后对每个bucket统计一个经验均值，作为校正因子 * 连续/高维特征：用一个很小的神经网络去预测原始精排分。 生效方式其实很简单，就是加了个消偏，精排分除以bias预估值。 ### Meta的MTMH [Optimizing Recall or Relevance? A Multi-Task Multi-Head Approach for Item-to-Item Retrieval in Recommendation](https://arxiv.org/pdf/2506.06239) KDD25 ![](/files/1WtBvhdJFJtB37URDld3) 同时考虑target item与trigger item的相关性和个性化。 多目标loss包括如下两部分： * 互动loss：正样本是trigger和target的共现，负样本是这个用户没交互过的item，用infoNCE loss * 内容相似loss：label是预训练的content encoder的输出向量的内积，和MTMH输出的item内积算一个kl距离 输入item特征，经过MTMH后有2个head： * head1：只学互动loss，保证模型对高热的召回能力 * head2：学多目标loss，即同时学互动和内容相似loss ![](/files/QwADykuIRKvrZYPGyIwt) content encoder的训练：对比学习 * 左边是text encoder（XLM-R-Large-550M）+vision encoder（VIT-H14-632M），只训练上面的mlp，输出是128dim * 右边是text encoder，输入concept(感觉是类似类目、tag之类的东西)，同样经过mlp输出128dim serving：2个head分别建索引，在线同一个trigger分别从这2个索引召回，再merge ### Meta的CABB建模 [Click A, Buy B: Rethinking Conversion Attribution in E-Commerce Recommendations](https://arxiv.org/pdf/2507.15113) 在同一个session内，CABA：click A buy A；CABB：click A buy B ![](/files/9QJZVX86ZhcnBZ6DtQXF) 正常的模型建模的是CABA，如图，加一个tower，建模CABB（点了A，但是买了别的东西），同时加上A和B的相似度来给loss加权（那些差得很远的就当成是噪音），其中相似度的逻辑： * 统计不同叶子类目在同一session里的共现信息 * 用传统的item-cf方法作用到叶子类目粒度，即每个叶子类目有一个长度为user数的向量，每个元素是用户对这个类目的加权求和($$w\_1\times buycnt+w\_2\times addcartcnt+w\_3\times clickcnt+ ...$$) * 不同类目的向量算cos，但因为每个数都是正的，所以算出来的cos是0到1之间，这个就是上面用到的相似度 另外看图里是这两个目标加权得到输出，去和一个ad conversion label算loss，这个label感觉应该是session内是否购买吧 ### Meta的MFLI [Rethinking ANN-based Retrieval: Multifaceted Learnable Index for Large-scale Recommendation System](https://arxiv.org/pdf/2602.16124) ![](/files/mMLcFmqGtNob0rzbRyUM) LI（learnable index）就是在训练的时候建好索引，参考当年的tdm ![](/files/bVsNjN61yhCkLgUGwwtr) 训练： * Trigger items：用户历史UIH（user interaction history）里的触发item，经过DNN得到trigger embed，候选item也过共享的DNN得到emb * MF-RQ：多个facet的RQ，其实就是F个角度，每个角度有一个L级码本，最终每个item emb能量化成F个index * 训练完后产出item2index：每个item对应F个tuple，每个tuple里有L级的sid，对于这一个tuple来讲，可以用如下类似N进制的方法写成一个整数(unified index)，所以每个item最终就能对应F个数； $$ c^f=\sum\_1^{L-1} c\_l^f \*\left(\Pi\_{k=1}^{L-l} N\_k\right)+c\_L^f, $$ serving： * index lookup：trigger直接查索引得到对应的index * index selection：根据一些规则选top K个index * item lookup：每个unified index也能对应一堆item，即图中的reverted map(有全量和增量的逻辑) * per-index rerank：每个index取top N的item，再merge ![](/files/YS11ePQ0XEWaf4osTKAy) ![](/files/5HStLwNLn2okTklbspZj) ### Meta的Adaptive Ranking Model [Meta Adaptive Ranking Model: Bending the Inference Scaling Curve to Serve LLM-Scale Models for Ads](https://engineering.fb.com/2026/03/31/ml-applications/meta-adaptive-ranking-model-bending-the-inference-scaling-curve-to-serve-llm-scale-models-for-ads/) 看着应该就是正常推荐精排模型的serving优化，还是基于wukong那一套架构，只是加了一些弹性计算 ![](/files/pG7ymTGGyGqWB8tcAKvd) ![](/files/Vm625KCyTpgRjyuEPrXk) * adaptive：不是所有请求都走同样重的模型，而是根据请求、上下文、用户意图等情况，动态匹配合适的计算复杂度 * request 级别共享计算，减少重复算user侧特征 * 长序列只做一次重计算，再给多个candidate复用 * 特征预处理往GPU迁移 * kernel fusion、Grouped GEMM、选择性FP8量化 * 多卡serving，解决超大sparse/dense单卡放不下的问题 ### 美团的NGA [NGA: Non-autoregressive Generative Auction with Global Externalities for Advertising Systems](https://arxiv.org/pdf/2506.05685) 美团的生成式广告混排 $$bid\_i$$是广告主的出价，$$p\_i$$是payment，可以理解为计费，即广告主实际出的钱，一般要求$$p\_i\le bid\_i$$，平台的目标如下： $$ \max *{\mathcal{M}} \mathbb{E}*{a \in \mathcal{A}}\[\operatorname{Rev}+\alpha \cdot \operatorname{Ord}]=\mathbb{E}*{a \in \mathcal{A}}\left(\sum*{i=1}^k p\_i \cdot \operatorname{ctr}\_i+\alpha \cdot \operatorname{ctr}\_i \cdot \operatorname{cvr}\_i\right), $$ ![](/files/iZWaqnPkO6p8sxgwvQHv) n个广告（图中的ad），m个自然结果（图中的oi，没有bid），最终的list长度为k generator部分： * m+n个item emb过几层网络，k个pos emb过几层网络，中间二者会进行cross attention(快手的[Non-autoregressive Generative Models for Reranking Recommendation](https://arxiv.org/pdf/2402.06871)，即item当成k/v，pos当成query)，得到$$(m+n)\times d$$的x和$$k\times d$$的t * x和t矩阵乘得到一个$$m+n\times k$$的矩阵，再和每个item的ctr/bid/cvr一起算出一个融合分并过softmax（这个softmax是保证当前item在所有位置上的概率和是1）得到z * per-persition受限解码：根据各种业务规则，选择每个位置z最高的item，类似beam search，生成多个候选list，每个list有k个item evaluator部分： * 输入generator产出的若干个list、对应的每个item的预估分Z、还有一个self-exclusion bidding profile $$B^{-}$$(即当前list里，除了自己以外，其他k-1个item的bid) * 上述输入经过3个网络，得到当前list的预估cvr $$\Gamma \in \mathbb{R}^{k \times 1}$$、预估ctr $$\Theta \in \mathbb{R}^{k \times 1}$$、预估payment $$\boldsymbol{p} \in \mathbb{R}^{k \times 1}$$（这个的输入包括了$$B^{-}$$），$$\operatorname{pay}\_i=\operatorname{bid}\_i \times p\_i$$ $$ \begin{aligned} & \Theta=\operatorname{Tower}\left(X\_{\text {list }} ; Z\right) \\ & \Gamma=\operatorname{Tower}\left(X\_{\text {list }} ; Z\right) \\ & \boldsymbol{p}=\operatorname{Tower}\left(X\_{\text {list }} ; Z ; B^{-}\right) \end{aligned} $$ * 最终算出来的list得分如下： $$ R=\sum\_{i=1}^k\left(\Theta\_i \times \operatorname{bid}\_i \times p\_i+\alpha \times \Theta\_i \times \Gamma\_i\right) $$ ### 美团的DSAIN [Deep Situation-Aware Interaction Network for Click-Through Rate Prediction](https://arxiv.org/pdf/2604.12298) ### 阿里的ULIM [User Long-Term Multi-Interest Retrieval Model for Recommendation](https://arxiv.org/pdf/2507.10097) ![](/files/dve5DqC1OQtxRz4pXHfC) * Category-Aware Hierarchical Dual-Interest Learning： * 短序列pooling得到p，同时过self-attn，然后和user profile一起过nn * 长序列按类别分组，分成K段得到“长类目序列”，每段（当成k/v）和p（当成query）算target-attn，然后和user profile一起过nn，得到K个向量 * target item和短序列的输出算内积，和长序列对应类目的emb的输出算内积 * Pointer-Enhanced Cascaded Category-to-Item Retrieval： * PGIN（Pointer-Generator Interest Network）： * pointer网络：长类目序列和短序列按时间序去重并merge得到query，然后和原始长类目序列和短序列分别算target attn，再过一个nn映射到每个类目的概率分布 * generator网络：长类目序列和短序列各自self attn，然后分别和user profile算taget attn，过nn后映射到每个类目的概率分布 * 通过一个p\_poi将两个分布加权求和 * Category-Constrained Retrieval：取PGIN产出的top K个类目，产出K+1个向量，然后去并行地做ANN召回： * 每个类目把对应的长类目序列拿出来，得到K个向量 * 把短序列向量取出来 最终是在淘宝秒杀app上的，有一些收益 论文中短序列最多100，不过作者没有说长序列有多长 ### 阿里的DGenCTR [基于离散扩散模型的生成式CTR预估](https://mp.weixin.qq.com/s/JKuVTu3UxYWa5rkK5v_3Ag) [DGenCTR: Towards a Universal Generative Paradigm for Click-Through Rate Prediction via Discrete Diffusion](https://arxiv.org/pdf/2508.14500) ![](/files/uf4bI6foBMo8pQsx2R4I) ![](/files/iSwFmHPcZZDMKLKMerbj) ### 阿里的STORE [STORE: Semantic Tokenization, Orthogonal Rotation and Efficient Attention for Scaling Up Ranking Models](https://arxiv.org/pdf/2511.18805v1) ![](/files/YVAZBpviJRlfLmLZqalW) * 将item id映射成语义id：item id高基数，语义id空间更稳定。用了OPMQ（Orthogonal, Parallel, Multi-expert Quantization），大概就是encoder里有多个专家，加了个正交loss让各专家尽量不同 * Orthogonal Rotation Transformation：低基数的特征人工分成K个组，concat后和K个正交矩阵乘，得到K个输出。同样加了loss限制各正交矩阵越远越好 * 高效Attention：就是Kimi的MoBA sid有效缓解了one-epoch现象，这个结构有一些关于sid数和层数的scaling law ![](/files/uoEtL0oiJXeVGuoz4nVQ) 有个疑问，这是个啥场景，gauc低可以理解，但auc咋也0.6几？ ### 快手的KuaiFormer [KuaiFormer: Transformer-Based Retrieval at Kuaishou](https://arxiv.org/pdf/2411.10057) ### 快手的CAVE [From Generation to Consumption: Personalized List Value Estimation for Re-ranking](https://arxiv.org/pdf/2508.02242) 重排里的list-wise evaluator，以前是对整个list给出价值预估，现在预估了一个用户退出的概率，只对退出之前的那些item的sub list预估价值 ### 快手的DimeRec [快手 | DimeRec: 扩散模型在序列推荐的应用](https://mp.weixin.qq.com/s/s21SJYsq8mRLt4zaQrAx5g) [DimeRec: A Unified Framework for Enhanced Sequential Recommendation via Generative Diffusion Models](https://arxiv.org/pdf/2408.12153) ### 快手的EMER [扔掉人工公式：快手EMER框架，用“会比较、自进化”的模型重构短视频推荐排序](https://mp.weixin.qq.com/s/4FQFrJxpCUvofzHotHUoqw) [An End-to-End Multi-objective Ensemble Ranking Framework for Video Recommendation](https://arxiv.org/pdf/2508.05093) ### 快手的GoalRank [快手GoalRank:告别G-E两阶段排序框架](https://mp.weixin.qq.com/s/X7KJz18vsqSPfhZBv6Cfiw) [GOALRANK: GROUP-RELATIVE OPTIMIZATION FOR A LARGE RANKING MODEL](https://arxiv.org/pdf/2509.22046) ### 字节的LMN [Large Memory Network for Recommendation](https://arxiv.org/abs/2502.05558) ### 字节的AsymDiffRec [Asymmetric Diffusion Recommendation Model](https://arxiv.org/pdf/2508.12706) ### Pinterest的Pinnerformer [PinnerFormer: Sequence Modeling for User Representation at Pinterest](https://arxiv.org/pdf/2205.04507) ### Pinterest的TransAct V2 [TransAct V2: Lifelong User Action Sequence Modeling on Pinterest Recommendation](https://arxiv.org/pdf/2506.02267) ### Pinterest的2阶段训练 [Taming the One-Epoch Phenomenon in Online Recommendation System by Two-stage Contrastive ID Pre-training](https://arxiv.org/pdf/2508.18700) ![](/files/QqQNgLikzsBDJ5BL9AI1) #### pretrain阶段 一个只有id的数据集，用的是pinnerformer里的对比学习loss，考虑了in-batch和uniform随机负例，其中$$\tau$$是可学习的温度。发现 $$ \mathcal{L}\left(u\_i, p\_i\right)=-\log \left(e^{u\_i^T p\_i / \tau} /\left(e^{u\_i^T p\_i / \tau}+\sum\_{j=1}^N e^{u\_i^T n\_j / \tau}\right)\right) $$ 发现2点： * 这个对比学习Loss能够降低长尾item的有效维度，从而缓解过拟合问题。随着epoch变多，这个loss的hitrate\@3会变得更好，而bce则会变差（过拟合）。 * 因为模型很简单，且收敛速度变快（不用像复杂模型需要那么多数据才能收敛），所以可以使用下游任务10倍的数据来训练，即天然地可以merge更多场景的数据进来。 #### finetune阶段 给更复杂的下游模型用 * 把预训练的loss函数拿过来，直接搞成一阶段，是负的 * 拿pretrain产出的emb过来，但freeze，有1.1%的收益 * 拿pretrain产出的emb过来，同时finetune，有1.3%的收益 ### Pinterest的multi-faceted预训练 [Multi-Faceted Large Embedding Tables for Pinterest Ads Ranking](https://arxiv.org/pdf/2508.05700) ![](/files/2tOIaWoyfjHacKvF3Hn9) 红色部分的item id的emb用的是上面那篇paper的2阶段方法，即下图的结构 ![](/files/A4ekXxKlKyCAWfC8A4JX) 第一张图里橙色的部分是下图的结构，异构的节点（user/item/广告/广告主/链接），边是有向边，包括两种：虚线是站外行为（这里是广告场景，应该就是比如去广告主的落地页里的成交类的转化），实线是站内行为。训练时给定头节点和尾节点，预测两者间是否有边以及边的类型，即link prediction。用的是知识图谱嵌入 (KGE)模型，例如TransR([Learning Entity and Relation Embeddings for Knowledge Graph Completion](https://cdn.aaai.org/ojs/9491/9491-13-13019-1-2-20201228.pdf))和TransE([Translating Embeddings for Modeling Multi-relational Data](https://proceedings.neurips.cc/paper_files/paper/2013/file/1cecc7a77928ca8133fa24680a88d2f9-Paper.pdf))。而不是graphsage，因为graphsage只是预测有没有边 ![](/files/AvC1TL0rkp0NTjDjQSxN) 这篇文章还在serving时做了cpu和gpu的分离，即emb放cpu里，gpu算计算图，这个比较常规 ### Pinterest的DRL-PUT [Deep Reinforcement Learning for Ranking Utility Tuning in the Ad Recommender System at Pinterest](https://www.arxiv.org/pdf/2509.05292) --- # Agent Instructions: Querying This Documentation If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question. Perform an HTTP GET request on the current page URL with the `ask` query parameter: ``` GET https://www.daiwk.net/1.7.llm_recommend.md?ask= ``` The question should be specific, self-contained, and written in natural language. The response will contain a direct answer to the question and relevant excerpts and sources from the documentation. Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.