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

发现性

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个文档，因为需要保证输出的是数字。

训练方法

用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

序列推荐的一些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的介绍：

原图里的下标有一些问题

码本的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

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

百度的COBRA

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

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

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的样本，以此类推

召回和排序的重定义

排序：推荐中的排序需要在尽量早的阶段进行target-aware的交互，而标准的自回归这种交互往往比较迟，例如在encoder的输出才用上了softmax。因此，设计了一种target-aware的cross-attention

生成式训练

但其实可以发现（这段是自己的理解），假设序列长度9，要预测第4个的时候，4-9的输入是mask掉的，但他们还是要进行后面的attention+ffn计算，其实是很浪费资源的，所以如上面“异构特征的统一表示”小节的那个图（生成主序列和辅助序列）所示，该模型直接只吐出x=x1-x3,y=x4作为训练样本就行了，这样既省掉了4-9的无用计算，也更便于并行（相比不拆batch的自回归）

生成式推荐中的高性能自注意力编码器

HSTU的单层包括3个部分：

其中，

对应到代码(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
- 这个做法受Neural collaborative filtering vs. matrix factorization revisited和Revisiting neural retrieval on accelerators的启发，用MLP来近似点积是很困难的。原因大概是nn需要调超参和足够的训练数据，在线算得又慢，而且本来内积效果就不错了，nn能带来的边际收益其实不明确。
表示转换：常见的如MoE、PLE等，主要思想就是对不同人群用特定的子网络。HSTU里的element-wise product也能达到MoE中的门控操作，只是可能有一个正则化因子的区别。

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

.0617

.2496

.0893

.3170

增加稀疏性

即：

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很重要：

因此激活函数的内存占用就成为了主要的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）。第一篇对应的结构如下：

所以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方法。

- 前向pass中，用于降低消耗
- requests之间，降低长尾耗时

其他

发现了scaling-law：

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

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

召回排序合为一体的生成式推荐——根据历史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

Meta的DTI（没落地）

Towards An Efficient LLM Training Paradigm for CTR Prediction

流式提示构建：摒弃传统 “滑动窗口” 范式为每个目标交互构建独特训练提示的做法，采用流式提示构建策略，将k个连续目标交互附加到初始n个上下文交互后形成一个提示，减少训练提示数量，降低计算冗余。
窗口因果注意力机制：为避免因提示长度增加带来的推理困境，引入窗口因果注意力机制，限制每个目标交互仅关注前序n个交互，使训练和推理过程一致，降低计算复杂度。

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

上面两种方法可以看成是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，推荐任务是训练目标。

假设用户点击了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效果最好，所以用了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如下：

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）来逼近这个排序。

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

Google拿推荐语料微调LLM

谷歌: 利用推荐知识对齐大语言模型

Aligning Large Language Models with Recommendation Knowledge

蚂蚁的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，用于蒸馏小型序列模型

consistency-aware weight：同时被teacher和student推荐的item更有可能是一个强正例

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的摘要能力提升内容推荐

百度的Agent4Ranking

Agent4Ranking: Semantic Robust Ranking via Personalized Query Rewriting Using Multi-agent LLM

其中的rewrite模块如下，搞4个agent，模拟4个人群的人与LLM对话，最终得到符合人群特点的rewrite

其中的rank模块如下，是一个bert，输入原始query和4个rewrites，加上target item，MMOE，算5个query间的js散度(robust loss)，以及综合输出和label的accuracy loss

小红书的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%做类目预测任务，然后走正常的语言模型自回归任务：

小红书的NoteLLM-2（落地） KDD25

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

微软的RecExplainer

RecExplainer: Aligning Large Language Models for Explaining Recommendation Models

https://github.com/microsoft/RecAI

快手的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。

整体的框架如下：

离线：
- 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基于置信域的逼近
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生成

用RecGen-llama系统性地分析用户的交互历史和反馈，建立一个详细的用户profile。
RecGen-llama对目标的新商品进行特征的详细描述。
RecGen-llama考虑用户画像与目标商品特性之间的契合度。
RecGen-llama反思用户在购买中可能对多样化的需求。

即RecGen-llama的输出是

<<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} 目标新商品。
让我们一步一步地开发上述考虑因素的思维链。
立即开始思维链：

性能分析

训练：发现相比用全量数据训练，用一半的数据训出来的模型在MMLU上效果更好，在推荐上的效果差不多，所以可以用小数据集来finetune
生成：对比Towards Open-World Recom- mendation with Knowledge Augmentation from Large Language Model提出的KAR(用户特征和item特征相对固定，可以提前存生成结果)，LLM-CF应用的场景有很多新用户和新item，但并不需要流式更新

在线部分

In-context CoT Examples Retrieval

做了2个trick：

In-context Chain of Thought Module

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

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

文本特征同样经过BGE encoder，

Model Training

最终的loss如下

Efficiency Analysis of Online Service

Google的STAR

腾讯的ECR Recsys24

RecSys'24最佳长论文|腾讯ECR:富有情感的对话式推荐系统

Towards Empathetic Conversational Recommender Systems

微信的PRECISE Recsys24

微信PRECISE:多场景落地基于协同信号和语义信息的生成式序列推荐

PRECISE: Pre-training Sequential Recommenders with Collaborative and Semantic Information

P5（学术界）RecSys22

Recommendation as Language Processing (RLP):A Unified Pretrain, Personalized Prompt & Predict Paradigm (P5)

CUP（学术界）没中

Recommendations by Concise User Profiles from Review Text

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

LLaMA-E（学术界）没中

LLaMA-E: Empowering E-commerce Authoring with Object-Interleaved Instruction Following

https://huggingface.co/DSMI/LLaMA-E#/

整体流程

instruction formulating: 为图中的任务写300个种子指令
instruction expansion: 让gpt作为teacher，对300个种子指令进行扩展，并由领域专家评估后，去重并保证质量，得到120k个指令作为训练集
- 针对结果是严格预定义好的，只重写instruction
```
[INST] Rewrite the following instruction
 while maintaining semantic consistency:
[/INST] <seed instructions>
```
- 针对鼓励生成结果有多样性的，
  - 结果生成：用上面重写过的instruction给LLM来获取结果
  [INST] <expanded instructions> [/INST] <seed inputs>
  - 结果重写：拿生成的结果给LLM生成更多样的表达
  [INST] Rewrite the following generated response to diversify its expression: [/INST] <responses>
instruction tuning: 对self-attention的q、k、v、o参数进行lora

设计的任务

示例：

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

清华，AAAI 24

设置一系列的task(100多个task)来finetune BLOOMZ(OPT+BLOOM的instruction-following模型)

命名实体识别：输入描述，输出brand、attr、component、product等
描述生成：输入query和候选doc list，选出最match的k个
对话intent提取：输入对话和候选intents（使用咨询、恢复订单、退款异常等），选出对应intent

Llama4Rec（学术界）SIGIR24

Integrating Large Language Models into Recommendation via Mutual Augmentation and Adaptive Aggregation SIGIR 24

prompt增强：在prompt里引入推荐模型的信息
- 相似用户也喜欢item4、item5
- 另一个推荐模型给出的预估是xxx
数据增强：通过LLM给推荐模型增加样本
- 直接推荐：给定2个候选item，LLM判断哪个更好
- 序列推荐：给定候选list，LLM给出topk
- 评分预测：给定候选item，LLM给出打分
adaptive aggregation：llm和推荐模型都给出排序，然后自定义融合公式算出融合分，得到最终排序

示例prompt如下

通过如上prompt构建一个instruct-tuning数据集，然后finetune一个llama2

SAGCN（学术界）ACM TOIS

Understanding Before Recommendation: Semantic Aspect-Aware Review Exploitation via Large Language Models

https://github.com/HuilinChenJN/LLMSAGCN

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

拿一些数据先用prompt1让LLM粗略标出用户评论所属的aspects，然后merge并去重得到候选的aspects列表
把这个候选aspects列表（图中的蓝色文字）丢给prompt2，让LLM对所有用户的评论打标

然后为每个aspect构建一个graph，过GCN

GReaT（学术界）ICLR23

Language Models are Realistic Tabular Data Generators

ICLR2023，https://github.com/kathrinse/be_great

通过自回归的LLM合成（synthesize）逼真的（realistic）表格化（tabular）数据

finetune：

把表格转化为逗号分隔的自然语言
随机交换几个属性的位置得到训练语料
基于交换后的语料进行自回归的finetune

sample：

基于如下3种方式产出precondition：
- 只输入属性名，例如“年龄”
- 输入name-value pair，例如“年龄=26岁”
- 输入多个name-value pair：例如“年龄=59岁，教育程度是硕士”
然后调用LLM输出其他属性
再转化为表格格式

ONCE（学术界）WSDM24

ONCE: Boosting Content-based Recommendation with Both Open- and Closed-source Large Language Models

WSDM24

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种数据如下：

Agent4Rec（学术界）SIGIR24

On Generative Agents in Recommendation SIGIR24

https://github.com/LehengTHU/Agent4Rec

核心代码是https://github.com/LehengTHU/Agent4Rec/blob/master/simulation/avatar.py，可以发现是用了langchain，包括其中的memory(请求openai的emb接口，本地faiss存)。

1000个真实用户，初始化1000个agent，3个数据集，搞了3000个agent，Agent模拟人的行为，点击、翻页、退出、打分、评价，评价标准：是否真的拟人

整体流程：

先在公开数据集上训一个推荐模型（mf/lightgcn等）
构建1000个agent，模拟和这个推荐模型交互，生成一些新的样本（假设推荐了xxx，你是不是会点？点了，正样本，没点负样本之类的）
加上这些新的样本再去重训推荐模型，发现效果有提升

3个module：

Profile module:
- 电影profile（流行度等+电影信息丢给gpt4产出的summary）
- 用户profile（社交属性、活跃度、从众心理（conformity）、diversity(更喜欢探索还是利用)、用户喜好tastes（用户历史行为丢给gpt4，让它总结用户喜欢什么不喜欢什么，会在用户有新行为后再update一下））
memory module:
- factual memory: 过去看了哪些电影、动作是什么
  - emotional memory: 看完后的情绪表达
action module:
- 看/打分/反馈
- 满意度
- 翻页/退出

图中的推荐系统是一个现成的系统/算法，例如MF、lightgcn等

word版的笔记：https://github.com/daiwk/collections/blob/master/assets/multi-agents.docx

类似的另一个：

MACRec: a Multi-Agent Collaboration Framework for Recommendation

RecPrompt（学术界）CIKM24

RecPrompt: A Self-tuning Prompting Framework for News Recommendation Using Large Language Models CIKM24

https://github.com/Ruixinhua/rec-prompt

如图的loop，所有LLM都是调接口的，没有tune

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: <START>C#, C#,..., C#<END>".

prompt optimizer：另一个LLM，用于生成更好的prompt。包括：
- refinement instruction
- 推荐prompt
- 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是否比之前的有提升
- 准确性：分母是预测出来的n个topic，分子是有多少个和对应的文章topic是match的
- 完整性：分母是用户历史点过的topic数，分子是用户历史点过的文章数

PO4ISR（学术界）没中

Large Language Models for Intent-Driven Session Recommendations

https://github.com/llm4sr/PO4ISR

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 KDD24

核心思想如下：

将一个item表示成3部分：id+title+attr，设计三种对应的instruct-tuning任务，其中||xx||+是一个特殊标记，类似于标识任务类型，对应的代码：

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的相似度（会考虑高热打压），加权融合出一个排序

constrained beam search：参考Autoregressive entity retrieval：代码：https://github.com/facebookresearch/GENRE，另外，可以发现title是没有bos和eos的，这样在检索/生成title的时候，是可以检索/生成子串的，也就是论文提到的position-free，同样的方法也可以用在instruct tuning阶段。

其他

ACL2024的recgpt 这个好像没啥用，RecGPT: Generative Pre-training for Text-based Recommendation

WWW 2024 | 工业界大模型在搜广推场景应用

LLM+Recommendation大模型推荐近期进展|含WWW, SIGIR, AAAI等顶会文章

ClickPrompt: CTR Models are Strong Prompt Generators for Adapting Language Models to CTR Prediction

recsys23的Leveraging Large Language Models for Sequential Recommendation 还有一篇Improving Sequential Recommendations with LLMs，对应的代码：https://github.com/dh-r/LLM-Sequential-Recommendation/tree/RecSys23

meta发的LLM-Rec: Personalized Recommendation via Prompting Large Language Models

生成式推荐系统近期研究工作梳理

腾讯广告基于混元大模型的生成式召回落地实践

CIKM 2024 | 大语言模型推荐中的协同过滤信号和语义信息的深度融合

Collaborative Cross-modal Fusion with Large Language Model for Recommendation

(toread)

生成式推荐最新进展 25年1月8号写的

小结

FFT：full finetuning
PT：prompt tuning
LAT：layerwise adapter tuning
OT：option tuning
T-FEW：few-shot peft

看着落地的

论文

公司

关键词

做法

ab收益

tune方式

华为

item llm+user llm

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

音乐推荐涨了播放量

frozen

快手

ItemLLM+user decoder

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

广告cvr+收入

frozen

蚂蚁

预先计算原子用户行为

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

广告ctr+cpm

FFT上层LLM

阿里

SFT+离线模拟+PRO

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

电商搜索，gmv+单量

FFT

看着没落地的

论文

公司

关键词

做法

tune方式

蚂蚁

蒸馏推荐理由

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

FFT

快手

基于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

google

2阶段训练+q-former

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

frozen

LLM+推荐：其他套路

ExFM

GPT4规模大模型落地，Meta提ExFM框架：万亿参数基础大模型的工业级落地成为可能

External Large Foundation Model: How to Efficiently Serve Trillions of Parameters for Online Ads Recommendation

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模型

数据集生产：
- 将所有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读取最新模型

VM的loss是：

引入以下3个方法强化FM的蒸馏效果：

LLM+推荐：概述

一些论文list

综述

概况

where-LLM用于特征工程

where-LLM作为特征编码器

where-LLM 用于打分函数

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+推荐：生成索引

DSI

Indexing方法

文档的表示

doc_id的表示

训练方法

vq-vae & rq-vae

vq-vae

rq-vae

TIGER

Tiger应用在排序

受限beam search相关

百度的COBRA

LLM+推荐：输入ID

快手的RecGPT

Meta的HSTU（落地）

背景

Sequential Transduction Tasks

生成式推荐中的高性能自注意力编码器

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

阿里的HeteroRec（落地）

Meta的DTI（没落地）

LLM+推荐：输入文本

华为的KAR（落地）

蚂蚁的BAHE（落地）

快手的LEARN（落地）

阿里的BEQUE（落地）

Google拿推荐语料微调LLM

蚂蚁的SLIM

OPPO的DLLM2REC

Google的ILM

Meta的EmbSum

百度的Agent4Ranking

小红书的NoteLLM（落地）

生成式对比学习

协同监督微调

小红书的NoteLLM-2（落地） KDD25

微软的RecExplainer

快手的LLM-CF

离线部分

在线部分

Google的STAR

腾讯的ECR Recsys24

微信的PRECISE Recsys24

P5（学术界）RecSys22

CUP（学术界）没中

LLaMA-E（学术界）没中

EcomGPT（学术界）AAAI24

Llama4Rec（学术界）SIGIR24

SAGCN（学术界）ACM TOIS

GReaT（学术界）ICLR23

ONCE（学术界）WSDM24

Agent4Rec（学术界）SIGIR24

RecPrompt（学术界）CIKM24

PO4ISR（学术界）没中

Transrec（学术界）KDD24

其他

小结

LLM+推荐：其他套路

ExFM