1.7.llm_recommend

LLM+推荐：概述

一些论文list

https://github.com/nancheng58/Awesome-LLM4RS-Papers

A Survey on Large Language Models for RecommendationRecommender Systems in the Era of Large Language Models (LLMs)

中科大LDS实验室的tutorial：XadC3O-large-language-models-for-recommendation-tutorial-slides.pdf

对应的datafun talk：当"狂飙"的大模型撞上推荐系统

大模型放进推荐系统怎么玩？微软亚研全面总结

生成式推荐综述：

Large Language Models for Generative Recommendation: A Survey and Visionary Discussions

A Review of Modern Recommender Systems Using Generative Models (Gen-RecSys)

大语言模型在推荐系统中的探索与应用

一文梳理业界落地LLM4Rec的若干范式-数万字超长文(建议收藏)

推荐算法月报(2025.2)：大模型的春风吹醒推荐算法，重磅大厂突破

推荐算法(2025.3.4)：速看！阿里Meta的最新研究成果

一文梳理业界落地LLM4Rec的若干范式-数万字超长文(建议收藏)

综述

概况

How Can Recommender Systems Benefit from Large Language Models: A Survey 基于这个组织

CRM(conventional recommendation models)

where-LLM用于特征工程

user-item level特征增强

通过LLM的世界知识来获取更好的user/item表示

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

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

• SAGCN：通过LLM标识出用户对item的评论是属于哪些aspect的，然后u有A个emb，i也有A个emb，构建A个U-I图，然后揉在一起过GCN

• CUP：把用户的一堆历史评论扔给chatgpt，让它总结出128个token，然后丢给双塔bert，另一个塔是item的描述，freeze bert底层，只tune上层

• LLaMA-E：instruction formulating为写300个种子指令，让gpt作为teacher，对300个种子指令进行扩展，并由领域专家评估后，去重并保证质量，得到120k个指令作为训练集，再用lora去instruct tuning

• EcomGPT：设置一系列的task(100多个task)来finetune BLOOMZ，包括命名实体识别、描述生成、对话intent提取等

instance-level样本生成

• GReaT：把表格化（tabular）数据转成自然语言，然后打乱顺序，自回归地finetune一个LLM，再拿tune完的LLM来合成（synthesize）逼真的（realistic）表格化数据

• ONCE：闭源LLM输出文本（user profiler、content summarizer、personalized content generator），给开源LLM得到user表示，item过开源LLM得到item表示，二者内积学ctr

• Agent4Rec：先训一个推荐模型，然后构建一个多智能体系统，模拟和这个推荐模型交互，产出新的样本给推荐模型做数据增强

• RecPrompt：给一个初始prompt，让LLM1得到推荐结果，拿一个monitor衡量这个结果和ground truth的mrr/ndcg，再用另一个LLM产出更好的prompt给第一个LLM用，如此迭代，得到一个best prompt

• PO4ISR：给初始prompt，收集error case让模型反思原因并refine出新的prompt，再augment出另一个prompt，并UCB选出最好的prompt，如此迭代

• BEQUE：query重写任务，SFT得到一个LLM，将其预测的若干个候选rewrites通过offline system的feedback得到排序，再通过PRO算法再tune LLM。

• Agent4Ranking：query重写任务，多个人群当成多个agent，每个通过多轮对话产出一个rewrite，再合在一起经过bert+mmoe计算robust损失+accuracy损失。

where-LLM作为特征编码器

表示增强

统一的跨域推荐

where-LLM 用于打分函数

Text Is All You Need: Learning Language Representations for Sequential Recommendation 亚马逊发的

https://github.com/AaronHeee/RecFormer

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

llm vs ID

推荐系统范式之争，LLM vs. ID？

Exploring the Upper Limits of Text-Based Collaborative Filtering Using Large Language Models: Discoveries and Insights

知乎的讨论

SIGIR2023 | ID vs 模态: 推荐系统ID范式有望被颠覆？

Where to Go Next for Recommender Systems? ID- vs. Modality-based Recommender Models Revisited

https://github.com/westlake-repl/IDvs.MoRec

对应的ppt

推荐生态系统

Modeling Recommender Ecosystems: Research Challenges at the Intersection of Mechanism Design, Reinforcement Learning and Generative Models

发现性

Diversifying by Intent in Recommender Systems，涨了dau等指标

LLM+推荐：生成索引

DSI

参考知乎：https://zhuanlan.zhihu.com/p/470182510

Transformer memory as a differentiable search index，提出的可微搜索索引（differentiable search index, DSI），拆成两个阶段：

• indexing：建立文档和doc_id的一一映射

• retrieval：根据query生成候选doc_ids

与Autoregressive Entity Retrieval提出的受限beam search的GENRE（代码https://github.com/facebookresearch/GENRE，解读Transformer中PrefixConstrainedLogitsProcessor类的解读）对比：

• 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），将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，对应的github：https://github.com/ArvinZhuang/DSI-QG，他也同时尝试复现DSI：https://github.com/ArvinZhuang/DSI-transformers，主要有如下两个地方：

• 准备数据，doc_id

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

• 训练和预测

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'])

• 对解码空间的限制：

    # 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://github.com/zalandoresearch/pytorch-vq-vae

用在推荐：

Learning Vector-Quantized Item Representation for Transferable Sequential Recommenders

https://github.com/RUCAIBox/VQ-Rec

rq-vae

Autoregressive Image Generation using Residual Quantization

TIGER

Recommender Systems with Generative Retrieval

序列推荐的一些paper：

• Session-based recommendations with recurrent neural networks：GRU4Rec首先把RNN用到推荐里

• Neural attentive session-based recommendation：提出NARM(Neural Attentive Session-based Recommendation)，在GRU里加了attention

• Next item recommendation with self-attention：AttRec在metric learning里引入了self-attention

• Self-attentive sequential recommendation：SASRec用了类似decoder-only的self-attention

• Bert4rec: Sequential recommendation with bidirectional encoder representations from transformer和Transformers4rec: Bridging the gap between nlp and sequential/session-based recommendation用了Transformer以及相关的mask策略

• S3-rec: Self-supervised learning for sequential recommendation with mutual information maximization：在预训练阶段引入了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构成的片段间

这些方法都是学习item的向量，然后用MIPS去ANN，而TIGER(Transformer Index for GEnerative Recommenders)则是生成式地直接预测item的语义id

rq-vae的介绍：

原图里的下标有一些问题

• $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的代码：https://github.com/kakaobrain/rq-vae-transformer/blob/main/rqvae/models/rqvae/quantizations.py#L237

• VQ部分：

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部分

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

RecSys'24 | 谷歌:使用语义ID提升推荐系统ID Embed泛化性

meta提升id emb稳定性

Meta广告:提出使用语义ID提升推荐系统ID Embed稳定性

Enhancing Embedding Representation Stability in Recommendation Systems with Semantic ID

受限beam search相关

Diverse Beam Search: Decoding Diverse Solutions from Neural Sequence Models

Autoregressive entity retrieval：代码：https://github.com/facebookresearch/GENRE

Autoregressive Search Engines: Generating Substrings as Document Identifiers：例如一个item可以写成<IDS> 1023 <IDE> Urban Decay Eyeshadow Palette Naked Heat <AS> Makeup <AE> <AS> Eyes <AE>，并通过wavelet tree存储，给定开始token（如<IDS>或者<AS>），可以在$O(Vlog(V))$里找出所有可能的后续tokens。代码：https://github.com/facebookresearch/SEAL

百度的COBRA

Sparse Meets Dense: Unified Generative Recommendations with Cascaded Sparse-Dense Representations

和tiger很像，主要区别是除了原来rq的code，还加了个dense emb进去

rq部分freeze，dense是拿item的明文特征过一个bert得到的cls emb，bert是训练的

decode出来有两个东西，rq的code和dense

• 先beam search出m个rq的code出来

• 然后每一个code和原来的seq一起输入decoder，得到的pred就是dense，再拿这个dense去ann找n个item

• 最后对这m*n个item拿两个相似度融合出一个得分，取topk出来

LLM+推荐：输入ID

快手的RecGPT

RecGPT: Generative Personalized Prompts for Sequential Recommendation via ChatGPT Training Paradigm

https://zhuanlan.zhihu.com/p/699985083

Meta的HSTU（落地）

如何评价Meta最新推荐论文: 生成式推荐打败深度分层架构推荐？

Actions Speak Louder than Words: Trillion-Parameter Sequential Transducers for Generative Recommendations

背景

大规模推荐系统依赖高基数(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中提到了NCE（normalized cross-entropy）指标：

可以发现，对于一个预训练好的模型来说，随着时间的变化，NCE的变化是很剧烈的，即数据分布是会漂移的，并不像nlp/cv一样有ground truth，所以传统推荐模型其实很难达到比较好的scaling能力。

需要克服的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），所以推荐系统每天要处理的tokens数量甚至比语言模型1-2个月处理的数量要大几个数量级

本文将用户action看成一个新的模态，2个主要的insights：

• 给定一个新的特征空间，核心的召回排序任务能被直接转换成生成式模型问题(序列直推任务，sequential transduction tasks)

• 这种范式能够系统性地解决传统推荐中的特征冗余、计算冗余、推理冗余，提升效率

Sequential Transduction Tasks

transductive learning（直推式学习） vs inductive learning（归纳式学习）https://www.zhihu.com/question/68275921/answer/529156908：

• 归纳式学习：训练只使用训练集，不使用测试集，训出的模型对测试集做预测，如监督学习。

• 直推式学习：训练时使用训练集，还使用测试集的特征，但不使用测试集的label，

异构特征的统一表示

• 稀疏特征：itemid、类目、城市、语言、社区等

  • 先选出最长的时间序列作为主时间序列，例如用户的交互序列。

  • 剩下的特征随时间变化较慢，如关注作者的属性。对于连续出现的片段（consecutive segment），只保留最开始的入口，这样对于主时间序列而言，并不会增加太多的序列长度。

• 数值型特征：这里指的是序列特征里每个item的统计特征，比如用户在时刻t对某个item的ctr。直接删了，因为DIN里提到随着序列长度增加，target-aware的序列建模方式能够捕捉到这种数值性特征

假设用户消费了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)$，那么总的训练消耗就是

如果设置$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的单层包括3个部分：

其中，

• $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)，其实就是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)，其实是在Self-attention with relative position representations一文提出的

对应到代码(https://github.com/facebookresearch/generative-recommenders/blob/main/modeling/sequential/hstu.py)里：

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，引入残差连接)。HSTU通过$\operatorname{Norm}(A(X) V(X)) \odot U(X)$来实现，将attention pooled后的结果直接和其他特征算element-wise product。

  • 这个做法受Neural collaborative filtering vs. matrix factorization revisited和Revisiting neural retrieval on accelerators的启发，用MLP来近似点积是很困难的。原因大概是nn需要调超参和足够的训练数据，在线算得又慢，而且本来内积效果就不错了，nn能带来的边际收益其实不明确。

  • 因为$U(X)$已经用过SiLU了，所以$\operatorname{Norm}(A(X) V(X)) \odot U(X)$可以看成是SwiGLU的变种（参考Glu variants improve transformer），因为前面在对比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会好得多

增加稀疏性

使用了一种高效的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启发，提出了SL(stochastic length)来增加用户历史序列的稀疏性，推荐系统中的用户行为往往有周期性，并且以不同形式呈现，因此引入稀疏性可以在效果不怎么损失的情况下显著减少encoder的代价，可以scale为$\Theta\left(\sum_i n_i^2\right)$

定义$\Gamma(n, L)$为一个函数，从原序列$x_0, \ldots, x_{n-1}$中选出长度为$L$的子序列，具体方案如下：

即：

• $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，即直接使用原序列)：

最小化激活值的内存使用

在推荐系统中，大的batchsize很重要：

• 训练吞吐：Software-hardware co-design for fast and scalable training of deep learning recommendation model一文说的

• 模型质量：Mixed negative sampling for learning two-tower neural networks in recommendations、A simple framework for contrastive learning of visual representations和Revisiting neural retrieval on accelerators

因此激活函数的内存占用就成为了主要的scaling瓶颈，这一点和llm不一样，llm一般是用小batchsize，并且内存主要由网络参数占据。HSTU设计了如下方式来减少激活函数的内存占用：

• 把attention外的linear layers从6减小到2，同时使用elementwise gating来降低MLP的计算（Transformer Quality in Linear Time和Efficiently modeling long sequences with structured state spaces）。第一篇对应的结构如下：

假设$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和FBGEMM: Enabling High-Performance Low-Precision Deep Learning Inference）

• 将优化器状态存在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)：

  • 前向pass中，用于降低消耗

  • requests之间，降低长尾耗时

其他

发现了scaling-law：

快手的OneRec（听说比较扯淡）

OneRec: Unifying Retrieve and Rank with Generative Recommender and Preference Alignment

OneRec Technical Report

「快手」全链路统一建模｜OneRec: Unifying Retrieve and Rank with Generative

效果&成本双突破！快手提出端到端生成式推荐系统OneRec！

召回排序合为一体的生成式推荐——根据历史session序列，预测下一个session。

阿里的HeteroRec（落地）

Hierarchical Causal Transformer with Heterogeneous Information for Expandable Sequential Recommendation

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预估

Meta的DTI（没落地）

Towards An Efficient LLM Training Paradigm for CTR Prediction

。。好像没啥，就是预测未来k个，并且设计了滑动窗口的mask（右下角）

华为的UniGRF（没落地）

Killing Two Birds with One Stone: Unifying Retrieval and Ranking with a Single Generative Recommendation Model

sigir‘25「华为」统一召回+排序框架

美团的MTGR（落地）

MTGR：美团外卖生成式推荐Scaling Law落地实践

推荐算法(2025.5.29)：美团的生成式推荐落地方案

MTGR: Industrial-Scale Generative Recommendation Framework in Meituan

听说是替换了精排

阿里的SORT-Gen（落地）

sigir'25「淘宝」多目标重排｜A Generative Re-ranking Model for List-level

A Generative Re-ranking Model for List-level Multi-objective Optimization at Taobao

将用户的所有行为聚合成一条样本。每个行为包括四个方面：用户侧、位置、商品侧、精排打分，将行为序列送入tansformer中。

保序回归损失

生成方法：先设计不同的rankscore得到多路序列候选，再比较每一路的top1，决定召回哪一路。

纯价值驱动的列表生成可能有同质化的风险，导致多样性降低。引入相似度惩罚：

小红书的RankGPT（落地）

小红书RankGPT:推荐系统生成式精排的落地实践

Towards Large-scale Generative Ranking

美团的UniROM（落地）

美团UniROM:广告End2End全链路生成式建模范式

One Model to Rank Them All: Unifying Online Advertising with End-to-End Learning

Meta的RPG（没落地）

Generating Long Semantic IDs in Parallel for Recommendation

训练：

• 长语义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推荐列表。

LLM+推荐：输入文本

华为的KAR（落地）

Towards Open-World Recommendation with Knowledge Augmentation from Large Language Models

• LLM生成user侧的preference reasoning知识

• LLM生成item侧的factual知识

• 这两部分知识输入一个encoder得到两个表示，然后再过个mmoe产出merge后reasoning augmented vec和fact augmented vec，一起作为CRM的输入特征。

对应的prompt如下：

看实验应该是用在召回，每个user和vec去找最像的k个item，但没法ann，只能暴力算

代码：https://github.com/YunjiaXi/Open-World-Knowledge-Augmented-Recommendation/blob/main/knowledge_encoding/utils.py，其实就是把模型输出的hidden states处理一下：

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

蚂蚁的BAHE（落地）

SIGIR'24 | 打破长度障碍：LLM增强的长文本用户行为CTR预测

Breaking the Length Barrier: LLM-Enhanced CTR Prediction in Long Textual User Behaviors

• 防止由于重复编码相同用户行为而产生的计算冗余：利用LLMs的预训练浅层提取来自用户序列的最细粒度的原子用户行为(例如购买星巴克、订酒店)的emb，并将它们存储在离线数据库中

• 从db里查出来，和item一起过LLMs的更深层可训练层

快手的LEARN（落地）

快手广告领域的大模型技术探索与实践

https://zhuanlan.zhihu.com/p/705497209

Knowledge Adaptation from Large Language Model to Recommendation for Practical Industrial Application

过往的llm+推荐的两种思路：

• freeze LLM参数并适应推荐领域数据：将用户行为历史改写成文本prompt，直接丢给LLM生成top-k推荐结果，例如：

  • Chat-rec: Towards interactive and explainable llms-augmented recommender system

  • Large Language Models are Zero-Shot Rankers for Recommender Systems

  • Is ChatGPT a Good Recommender? A Preliminary Study

  • LLM-Rec: Personalized Recommendation via Prompting Large Language Models

  • Large Language Models are Competitive Near Cold-start Recommenders for Language- and Item-based Preferences

  • Is ChatGPT Fair for Recommendation? Evaluating Fairness in Large Language Model Recommendation

• 在推荐领域的特定文本数据集上微调LLM：利用LLM捕捉用户行为序列，通过设计提示prompt，使LLM学习用户和物品之间的潜在关系，在预测任务中理解用户的偏好变化和行为模式，从而更好地预测用户可能感兴趣的物品，例如：

  • A Bi-Step Grounding Paradigm for Large Language Models in Recommendation Systems

  • Tallrec: An effective and efficient tuning framework to align large language model with recommendation

  • Llara: Aligning large language models with sequential recommenders

  • ReLLa: Retrieval-enhanced Large Language Models for Lifelong Sequential Behavior Comprehension in Recommendation

  • Where to Go Next for Recommender Systems? ID- vs. Modality-based Recommender Models Revisited

上面两种方法可以看成是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发现了全量参数微调会导致LLM对原有知识domain的严重的灾难性遗忘。

  • 训练目标不对齐（misalignment）：LLM是next token prediction，学习大语料的general知识；finetune则主要是检索类的任务，强依赖用户-item的交互行为

其实有rec-to-llm和llm-to-rec两类想法

快手商业化把llm用到推荐的思路变化：

本文提出了LEARN(Llm-driven knowlEdge Adaptive RecommeNdation)，实现了LLM-to-Rec，让LLM作为content extractor，推荐任务是训练目标。

• 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}$

假设用户点击了H+T个item，拆成1H和H+1H+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），即从1~H里随机挑m个出来，每一个去预估H+1~H+T里的随机一个正样本

在线使用时如下图，其中user emb和item emb就是两个tower的输出，会先concat并过个小fusion module得到fusion emb，然后一方面过个mlp算个cvr loss，另一方面和user emb、item emb还有其他特征concat再送给后面的模块正常算ranking loss

阿里的BEQUE（落地）

LLM落地淘宝电商搜索场景，显著提升长尾query改写效果

Large Language Model based Long-tail Query Rewriting in Taobao Search WWW24

• multi-instructions的sft：基于在线日志，通过拒绝采样得到multi-instrunctions的SFT数据集，任务是重写query，还混合了质量分类、query改正、CoT任务

其中的3个task如下：

• offline feedback：用训好的LLM生成多个候选rewrites，构建了一个离线的淘宝系统，对这些候选rewrites进行搜索得到结果，并用结果的quality scores来对候选rewrites进行排序

• objective alignment：基于候选的rewrites的排序，使用PRO方法（Preference ranking optimization for human alignment）来逼近这个排序。

给定顺序$y_1>y_2$，preference probability如下，其中$r(\cdot)$是reward函数：

对应的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)$：

应用：离线刷库，实验的gmv、单量都有收益，长尾query效果更好

小红书的NoteLLM（落地）

WWW'24 | 小红书NoteLLM: 大语言模型用于I2I笔记推荐

NoteLLM: A Retrievable Large Language Model for Note Recommendation

3个任务：

• I2I笔记推荐任务: 给定目标笔记，基于LLM从内容池中找出top-k个相似笔记

• 主题标签生成任务：基于笔记的标题和内容, 用LLM生成对应的k个主题标签。

• 类目生成任务：基于笔记的标题、内容、主题标签，用LLM生成对应的类目。

笔记压缩prompt：

[bos]<instruction><input notes>The compression word is:"[EMB]".<output guidance><output>[eos]

其中的[EMB]是一个特殊token，类比bert里的[CLS]

生成式对比学习

生成式对比学习(Generative-Contrastive Learning,GCL)

• 通过统计共现信息，同时打压热门，得到item pair对

• 由于LLMs的自回归特性, 将[EMB]的前一个token对应的最后一个隐层输出经过一个linear layer得到一个d维向量

对于batchsize=B的batch来说，有B个pair对，即2B个item，那么对它们算一个对比学习的loss，其中的sim是cos相似度：

协同监督微调

协同监督微调(Collaborative Supervised Fine-Tuning,CSFT)将主题标签生成任务和类目生成任务联合训练，一个batch里40%的样本执行主题标签生成任务，剩下的60%做类目预测任务，然后走正常的语言模型自回归任务：

然后将这两个loss加权求和($\alpha = 0.01$)：

小红书的NoteLLM-2（落地）

小红书 NoteLLM-2：用于推荐的多模态表征

Google的2个LLM（落地）

谷歌短视频推荐:用户反馈对齐的LLM用于新颖推荐

novelty LLM

Llms for user interest exploration in large-scale recommendation systems

对llm进行sft，输入用户喜欢的K个cluster，预测下一个cluster。

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

先拿novelty-llm开实验(也可以直接拿线上这路召回的结果)，收集用户对推荐出来的这些类目的正负反馈，然后组织成pointwise或pairwise的语料，训练一个类似reward model的alignment-llm。

纯离线infer：用novelty llm采用比较高的temperature预测多次，然后用alignment llm打分选挑出topk的cluster，存起来给线上用。

实验对比线上基线的novelty-llm，pointwise和pairwise在多样性、正反馈动作率、完成率均有提升，鈤pointise训练得更快，所以最终推全pointwise

Google的惊喜度推荐（落地）

推荐算法(2025.6.11)：Google的意外推荐

Serendipitous Recommendation with Multimodal LLM

基于Cluster Anchor Regularization to Alleviate Popularity Bias in Recommender Systems搞了一个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丢到训练数据里去

• 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小时就能推理完；后来做了增量更新版本，但因为高热视频变化不多，所以速度也可以接受

快手的LARM（落地）

LLM-Alignment Live-Streaming Recommendation

结合直播的特点：同一个直播间在不同时间段的内容不同，不同用户由于进房时间不同，看到同一个直播间的内容也不同。

整体思路还是比较简单的

• 输入直播间和主播的基础信息，拿100B的llm标出来一些数据（生成如下的问答pair对、以及对直播内容的总结与理解），去finetune一个7B的llm

• 用这个7B LLM产出emb（pooling）结合主播侧特征通过gating融合得到直播间emb，和user去双塔inbatch softmax

• 【这一步的时效性比较高，每30秒更新一次】拿上面融合过的emb，通过rq-vae进行聚类，把对应的code扔给线上推荐模型

qa类prompt：

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：

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": ... },}

实验部分列了两个主场景的收益，但没有说实验流量

阿里的URM（落地？）

当购物用上大模型！阿里妈妈首发世界知识大模型，破解两大推荐难题

Large Language Models Are Universal Recommendation Learners

2个特殊token：

• [UM]对应的输出通过用户建模头$h_{UM}$映射到用户表示空间，用于候选商品的生成。如图，每个item对应一个[UM]；

• [LM]及其后续符号对应的输出通过语言模型头$h_{LM}$映射到文本空间，用于文本token的生成。

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

Spotify的LLM Preview生成

Transforming Podcast Preview Generation: From Expert Models to LLM-Based Systems

推荐算法(2025.6.3)：Spotify的LLM应用，效果明显

蚂蚁的SLIM（没落地）

蚂蚁集团在大模型推荐上的算法和应用

Can Small Language Models be Good Reasoners for Sequential Recommendation?

• 第一阶段：蒸馏大型GPT模型到较小的模型（如LLAMA2/3），来增强推理能力。

  • 通过预设的 prompt，大模型生成推荐理由，这些理由基于预定义的模板。接着，

  • 使用简化的推理模板请求小模型进行推荐和理由生成。

• 第二阶段：利用生成式Loss来微调小模型，使其具备推理能力。

  • 模型训练完成，将通过prompt为用户行为提供T+1推理。

  • 推理结果通过文本编码器（Text Encoder）转化为表征，这些表征将直接应用于线上模型。

OPPO的DLLM2REC（没落地）

在蚂蚁的SLIM的基础上，希望将LLAMA进一步压缩至更小的序列模型。在实验中遇到几个挑战：

• 蒸馏过程中教师模型的知识可靠性存疑

• 从语言模型到序列模型的蒸馏跨越了不同的模型类型，带来两个主要问题：

  • 参数差距大，学生模型难以容纳教师模型的知识

  • 语义不一致，因为序列模型与原始语言模型之间存在天然差异

Distillation Matters: Empowering Sequential Recommenders to Match the Performance of Large Language Models

包含两个关键部分：基于Ranking的蒸馏策略(Importance-aware Ranking Distillation)和Embedding对齐(Collaborative Embedding Distillation)

核心在于排名蒸馏，采取了如下三个策略

• 选择LLAMA2作为教师模型，认为其排名靠前的分值更高；

• 考虑LLM生成的描述与目标物品（Target Item）的接近程度，增加其排名；

• 若教师模型（Teacher Model）认为某物品是优质且排名靠前的，学生模型（Student Model）也会给予其更高排名。

通过这些策略，设计了Ranking Loss，用于蒸馏小型序列模型

其中，$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更有可能是一个强正例

快手的LLM-CF（没落地）

2024'快手提出LLM-CF框架，借助LLM的链式思维（COT）推理提升推荐系统性能

CIKM24，Large Language Models Enhanced Collaborative Filtering

https://anonymous.4open.science/r/LLM-CF-AD78/readme.md

简单总结：

拿推荐数据对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和WWW24的ReLLa: Retrieval-enhanced Large Language Models for Lifelong Sequential Behavior Comprehension in Recommendation），把推荐变成了一个让模型输出yes/no的2分类任务。这里的$x_i$是包括用户特征和当前item特征的文本描述，$y_i$是点击的label(0/1)。

整体的框架如下：

• 离线：

  • 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和HyPe: Better Pre-trained Language Model Fine-tuning with Hidden Representation Perturbation，用推荐数据finetune的时候，在input的embedding层加噪声

• R3F：Better Fine-Tuning by Reducing Representational Collapse基于置信域的逼近

• Wise-FT：Robust Fine-Tuning of Zero-Shot Models，这个引用量挺高的，https://github.com/mlfoundations/wise-ft，将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发现通过mixed-data finetuning能够保持通用能力的情况下，提升数学和代码能力

对比下来发现，R3F在推荐和MMLU上都最差，full在推荐上效果最好但在MMLU上不太行，RecGen在推荐的效果还不错在MMLU也没降多少，所以将推荐数据和通用数据(如LIMA(Lima: Less is more for alignment)和alpaca-gpt4(Instruction tuning with gpt-4))混合。

CoT Reasoning生成

通过如下的CoT prompt $\mathcal{P}$，可以实现如下过程：

• 用RecGen-llama系统性地分析用户的交互历史和反馈，建立一个详细的用户profile。

• RecGen-llama对目标的新商品进行特征的详细描述。

• RecGen-llama考虑用户画像与目标商品特性之间的契合度。

• RecGen-llama反思用户在购买中可能对多样化的需求。

即RecGen-llama的输出是

其中的CoT prompt $\mathcal{P}$是：

<<SYS>> 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. <</SYS>>
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: 

---------------

<<SYS>> 作为一个用于分析消费者行为的AI模型，您的任务是生成一条思维链，考虑以下几点：
1. 利用用户的互动历史和评论总结他们的个人画像。
2. 介绍目标新商品并详细说明其特点。此外，整合与当前目标新商品相关的其他商品信息。
3. 思考用户画像与目标商品特性之间的契合度。
4. 反思用户在购买中可能对多样化的需求。
您的输出应当是一个清晰且逻辑严谨的思维链，确保您的分析公正无偏，重点应放在理解影响用户决策的因素。<</SYS>>
请生成一个思维链，基于用户的……考虑这些因素可能如何影响他们对目标新商品的决策。
{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提出的KAR(用户特征和item特征相对固定，可以提前存生成结果)，LLM-CF应用的场景有很多新用户和新item，但并不需要流式更新

在线部分

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)作为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就是

然后得到这些token对应的embs：

其中，（图中右上角橙色部分）

• 文本特征同样经过BGE encoder，

• $x_i$里的推荐特征则经过推荐模型的feature encoder得到$r_i$，

• CoT reasoning $c$则是通过text encoder和MLP映射

• label $l$也是一个0/1的id对应的embedding

然后把$\mathbf{E}$经过若干层transformer decoder，得到输出的表示:

最终得到的表示可以是这个输出的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：

最终的loss如下

Efficiency Analysis of Online Service

图中的蓝色火焰部分需要在线计算，而因为$K=4$，所以很轻量

Google的ILM（没落地）

Item-Language Model for Conversational Recommendation

适用场景如下，{user}可以看成一种特殊的{item}，{history}是若干个item

参考BLIP-2（Blip-2: bootstrapping language-image pre-training with frozen image encoders and large language models）提出的Q-former：

引入了Q-former

• phase1：表示学习，交替训练如下两类表示学习

  • item-text表示学习:

    • query的tokens和item的cf emb过cross attn后，拿cls的输出得到v1

    • text过attn得到v2

    • v1和v2算item-text对比学习

    • v2走一个自回归的任务(item grounded text generation)

  • item-item表示学习

    • query的tokens和item1的cf emb过cross attn后，拿cls的输出得到v1

    • query的tokens和item2的cf emb过cross attn后，拿cls的输出得到v2

    • v1和v2算item-item的对比学习

• phase2：item-language model训练

  • Q-former的item encoder经过一个linear输入到LLM中

  • LLM参数freeze，只tune Q-former的参数和linear

Meta的EmbSum（没落地）

EmbSum: Leveraging the Summarization Capabilities of Large Language Models for Content-Based Recommendations

RecSys'24 | Meta:使用LLM的摘要能力提升内容推荐

• user session encoding：先将用户k个行为序列化分成$g$个session，每个session里有$p$个content，这p个content的文本单独过transformer encoder（T5 small），拿开始的token（[SOS]）对应的输出当成文本表示

• user engagement summarization：将用户的历史丢到一个prompt里去，让llm总结出一段话，然后参考Leveraging Passage Retrieval with Generative Models for Open Domain Question Answering，把llm输出的所有tokens的hidden states concat在一起，再丢给T5 decoder，并加一个自回归的loss，其中$y_j^{u_i}$表示生成的用户$u_i$的summary，而$|y_j^{u_i}|$是summary的长度

• user poly embedding（upe）：把decoder最后一个token（[EOS]）拿出来，和前面的k个session encoding一起得到一个$Z \in \mathrm{R}^{(k+1) \times d}$，然后过一个poly-attention layer，得到用户的$m$个兴趣表示$A \in \mathrm{R}^{m \times d}$，其中每个向量是$\alpha_a=\operatorname{softmax}\left[c_a \tanh \left(Z W^f\right)^{\top}\right] Z$，其中$c_a \in \mathrm{R}^{1 \times p}$和$W^f \in \mathrm{R}^{d \times p}$是可训练的参数

• content poly embedding（cpe）：和upe类似，k个session encoding换成当前item的encoder输出，UPE里的[EOS]换成当前content的下一个token即[SOS]，然后得到$n$个$d$维表示$B$

• 融合：$A^TB$可以算出一个$m\times n$的相似矩阵，然后flatten，得到一个$mn$维的向量，同理算一下，得到的$s^i_j$就是两个向量的内积，即相似度的得分了