CURP: Codebook-based Continuous User Representation for Personalized Generation with LLMs

Liang Wang; Xiaoyou Liu; Xinyi Mou; Xuanjing Huang; Zhongyu Wei

REVIEW 4 major objections 6 minor 1 cited by

CURP: Codebook-based Continuous User Representation for Personalized Generation with LLMs

T0 review · 4 major / 6 minor · reviewed 2026-08-03 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗

Pith's one-line read CURP claims that a user's identity can be compressed into a few discrete, interpretable prototypes in a shared codebook, letting a frozen 8B LLM generate personalized text with only about 20M trainable parameters.

desk verdict The codebook idea is worth a look, but the BLEU scores in Table 1 are mathematically impossible, which undermines the empirical claims. read the letter →

arxiv 2602.00742 v2 pith:U4DDMUPT submitted 2026-01-31 cs.CL

Liang Wang , Xinyi Mou , Xiaoyou Liu , Xuanjing Huang , Zhongyu Wei This is my paper

classification cs.CL

keywords usermodelingpersonalizationlargelanguagemodelscodebookprototyperepresentationproductquantizationplug-and-playadaptationinterpretability

verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

This paper claims that a user's identity can be compressed into a short combination of discrete, interpretable prototypes (e.g., #Teenager + #Faithful + #Funny) stored in a shared codebook, and that feeding those prototypes to a frozen LLM through a small adapter produces personalized text as good as per-user fine-tuning. The framework, CURP, uses a two-stage pipeline: first it builds a codebook of 1,000 prototypes from a large pool of Reddit QA histories, then it trains a ~20M-parameter adapter that maps each user's prototype combination into the LLM's embedding space. On four generation tasks (Reddit QA, News Headline, Tweet Paraphrase, Review Writing) it reports state-of-the-art scores on 70% of metrics while using only 0.2% of the model's parameters, and the codebook indices are shown to correlate with topics, sentiment, and stance. A sympathetic reader would care because this promises to make personalization scalable and privacy-friendly: instead of fine-tuning a model per user or sending raw histories to the cloud, you transmit a few codebook indices. The paper's own ablation suggests the quantization itself loses little performance; the major open risk is whether the Reddit-built codebook truly transfers to other domains, since transfer is only measured by usage counts, not output quality.

What carries the argument

The core object is the prototype codebook C: 1,000 learnable vectors in each of 4 subspaces, built by balanced k-means on frozen encoder embeddings of user histories, kept frozen during adapter training. Product quantization maps each user event embedding to 4 discrete indices (e.g., [505, 910, 204, 56]), one per subspace; a 2-layer MLP projects these quantized embeddings into the frozen LLM's input space so they can be prepended to the query. The codebook does the load-bearing work: it turns noisy text histories into compact, interpretable, transferable user traits, and the training losses (quantization, diversity, usage) are designed to keep all 1,000 entries active and spread out.

What would settle it

Train the codebook on Reddit QA only, freeze it, and evaluate CURP on a held-out domain that is semantically distant (e.g., medical forum posts or code review comments) against a version whose codebook was trained on that domain's own histories. If the cross-domain version does not beat zero-shot or falls far behind the in-domain version on ROUGE/BLEU/similarity, the generalization claim is refuted. Additionally, the privacy claim could be tested by attempting to reconstruct user histories from codebook indices using the public encoder and codebook.

Watch

Extended reading notes

Core claim

The central claim is that user-specific generation can be reduced to selecting a small combination of shared semantic prototypes. CURP encodes each historical behavior with a bidirectional encoder, quantizes the embedding into 4 subspaces via product quantization against a balanced k-means codebook of 1,000 entries, and then concatenates the quantized prototype embeddings (projected by an MLP) to the task query inside a frozen LLM. Training has two stages: constructing the codebook from ~24M Reddit QA histories, and aligning prototypes to generation by maximizing likelihood of the user's response. The method reports best scores on most metrics across four tasks with only ~20M trainable param

Load-bearing premise

The load-bearing premise is that prototypes learned from Reddit question-answer histories are universal enough to represent user traits in other domains (news, tweets, reviews); if those prototypes do not transfer, the headline results on the other three tasks lose their support.

Editorial extensions

If this is right

A single 20M-parameter adapter can personalize a frozen 8B LLM across multiple tasks, eliminating per-user fine-tuning costs for large user populations.
The representation is compact enough for cloud-edge pipelines: only 4 discrete indices per history (or per user) need to be transmitted, not raw text or dense embeddings.
The codebook's subspaces are interpretable: topic anchors, content type, and sentiment/stance can be read off the indices, enabling controllable generation by editing prototype combinations.
Because the codebook is frozen and shared, the method is model-agnostic; the paper shows competitive results when swapping encoder and decoder backbones.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

A natural extension is to treat codebook indices as a compact user feature for standard recommender or RL personalization, where the same discrete code could condition multiple surface tasks; the paper does not explore this.
The privacy claim rests on indices being non-invertible; a testable follow-up is whether an adversary with the codebook and encoder can reconstruct rough history content from indices, and whether differential privacy would be needed.
The paper's own limitation—discarding fine-grained lexical habits—suggests a hybrid that augments prototypes with a short textual snippet or a per-user token might beat either extreme; that is inference, not their experiment.
Cross-domain transfer is measured only by codebook utilization (998/1000 entries used on RQ, 524 on NH, etc.); the real test would be reporting generation metrics on a codebook trained exclusively on Reddit and applied to a genuinely distant domain, e.g., medical advice or code generation.

Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Desk Editor's Note

read the letter

Quick take: the core idea—discretizing a user encoder's outputs into a shared product-quantized codebook and injecting the codes into a frozen LLM via a small adapter—is clearly presented and plausibly useful. The two-stage training is clean, the ablation is honest about the codebook adding little on the headline metrics, and the interpretability analysis (subspaces tracking topic, sentiment) is suggestive. There's real thinking here, and the paper is readable.

But the numbers don't hold up. Table 1 reports BLEU scores of 110 for LoRA, 109 for PPlug, and 108 for CURP on Tweet Paraphrase. Standard BLEU is bounded above by 100 (or 1.0). There is no legitimate way to get 110. That's not a minor typo—it's a systematic problem across methods, and BLEU is one of the five metrics behind the abstract's 'superior performance' claim. I'd want the authors to explain the exact computation. Until then, every conclusion built on those metrics is suspect. Also, the '70% of metrics' claim: counting the table, CURP is strictly best on 12 of 20 cells—60%, not 70%. And if you remove the invalid BLEU cells, the margin shrinks further.

The cross-domain generalization evidence is weak: Section 5.3.2 reports only how many codebook entries are used per task (998, 524, 667, 743), not whether the transferred codes improve generation quality. Since the codebook is built entirely from Reddit QA, the News/Tweet/Review results could simply reflect the adapter adapting to the task while the codebook is just a noise source. The ablation in Table 2 is consistent with that: removing the codebook changes R-1 and R-L by about 0.01 on three of four tasks. So the central hypothesis—that the codebook is what helps—is not strongly supported.

To be fair, the paper acknowledges in Section 7 that ROUGE/BLEU/similarity 'remains difficult to deeply explore the degree of personalization,' and they avoid LLM-as-judge for good reasons. But you can't then lean on those metrics for the main argument. Also, no error bars or significance tests anywhere; with differences of 0.01–0.02, that matters.

Who this is for: someone working on personalized generation with frozen LLMs will find the formulation useful, and the interpretability analysis is genuinely illustrative. But the paper is not ready for acceptance. The BLEU issue alone demands at least a revision and re-execution; if the numbers are a metric bug, the results may change. I'd send it to peer review—the idea is good enough that a careful referee could help the authors fix the evaluation—but it would be a conditional at best.

Referee Report

4 major / 6 minor

Summary. The paper proposes CURP, a framework for personalizing LLM generation through a bidirectional user encoder and a discrete prototype codebook. User histories are encoded with Contriever, quantized via product quantization into a balanced k-means codebook, and projected through an MLP into a frozen Qwen-2.5 LLM. Training proceeds in two stages: prototype codebook construction (PCC) on ALIGNX Reddit QA histories, and prototype behavior aligning (PBA) on task-specific data. Experiments on Reddit QA, News Headline, Tweet Paraphrase, and Review Writing compare CURP against prompting and PEFT baselines using ROUGE, BLEU, and semantic similarity. The paper claims state-of-the-art results on 70% of metrics with only 20M trainable parameters, and reports additional analyses for interpretability, codebook design, cross-architecture generalization, and history length robustness.

Significance. If the reported results are correct, CURP provides a practical middle ground between expensive per-user fine-tuning and noisy text prompting. The decoupling of a shared interpretable codebook from the decoder, the small parameter overhead, and the reported gains across multiple tasks would be useful contributions to personalized generation. The paper also ships a public codebase and specifies a deterministic inference setting, which aids reproducibility. However, the empirical claims rest on several metrics whose validity is currently questionable and on ablations that do not demonstrate a performance contribution from the codebook itself.

major comments (4)

[§5.1, Table 1] The reported BLEU values for Tweet Paraphrase (LoRA=110, PPlug=109, CURP=108) are mathematically impossible: BLEU is bounded above by 100 when expressed as a percentage, since both the brevity penalty and modified n-gram precision are at most 1. A similar anomaly appears in Table 3, where the Contriever+LLaMA row reports News Headline BLEU as .027 instead of a plausibly scaled value (27). This indicates a bug in the evaluation script or a scaling error, and it undermines the reliability of every BLEU entry in the paper. Since BLEU is one of the five metrics used to support the abstract's 'superior performance' and Section 5.1's '70% of metrics' claim, the authors must rerun all BLEU evaluations with a standard, bounded implementation, report the exact tokenization and smoothing configuration, and correct Tables 1–3. Without this, the numerical foundation of the central claim is unreliabl
[§5.2, Table 2] The ablation removing the codebook (w/o cb) shows that the codebook contributes little to the reported performance: most differences are below 0.01, and on some metrics the non-quantized version is better (e.g., RQ BLEU 74 vs 71, NH BLEU 32 vs 28, RW R-L .155 vs .157 aside). The paper's framing in the abstract and Section 5.1 attributes the performance gain to the prototype codebook, but the ablation suggests the gain comes almost entirely from the continuous user embedding and MLP projection. The authors should either identify a configuration or task where quantization gives a clear accuracy benefit, or substantially rewrite the claims to present the codebook as an interpretability/privacy mechanism rather than the source of predictive performance. This is load-bearing because the title and core contribution center on the codebook.
[§5.1, Table 1 (general)] No error bars, multiple seeds, or significance tests are reported. Many of the claimed improvements are very small and could easily arise from noise. For example, RQ R-2 .027 vs .026, RQ Sim .850 vs .845, NH R-L .179 vs .170, RW R-L .157 vs .152, and RW R-2 .058 vs .053. Without at least multiple runs or pairwise significance tests (e.g., bootstrap or paired tests over the evaluation set), the 'superior performance compared to strong baselines' claim is not statistically grounded. The authors should provide confidence intervals or significance tests for the main results, especially for metrics where the margin over the second-best baseline is under 0.01.
[§5.3.2] The cross-task generalization analysis reports only codebook usage counts (998, 524, 667, 743), not generation quality on downstream tasks. The assertion that these counts 'demonstrate that the learned user prototypes encode transferable semantic patterns' is a leap: high usage of entries does not imply that the transferred codebook yields good outputs. The main experiments already show strong performance with an ALIGNX-trained codebook, but that codebook is used together with task-specific MLP training. To support the transferability claim, the authors should either report generation metrics for the frozen-codebook scenario or remove the overreach from the text.

minor comments (6)

[§3.3 vs Appendix B] The main text states the decoder is Qwen-2.5-8B, while Appendix B says Qwen-2.5-7B. Please unify the model size. (Qwen-2.5 actually has 7B and 8B variants; clarify which one is used.)
[§1 (Contributions)] Typo 'prototyoes' should be 'prototypes'.
[§1 (Introduction)] Typo 'us er baheviors' should be 'user behaviors'.
[Table 1] The row labeled 'Len&Para' is not clearly explained in the caption. It seems to list average prompt length for prompt-based methods and trainable parameters for training-based methods, but the caption should say so explicitly and define 'L' and 'U'.
[Appendix A] The text says 'task-specific training data is utilized exclusively for the ID component' but 'ID' is not defined. Presumably this is the MLP projector; please name it consistently.
[Figure 3] The figure is hard to read in the PDF: axis labels and legend text are very small, and the 'Random' condition in subplot (b) is difficult to distinguish. Please enlarge and clarify.

Circularity Check

0 steps flagged · score 1.0 of 10

No significant circularity: CURP is a standard supervised train/validate pipeline; the few self-citations are background, not load-bearing.

full rationale

The derivation chain is self-contained in the relevant sense. PCC (Eqs. 1-7) clusters frozen Contriever embeddings of historical behaviors from an ALIGNX training subset into a 1000-entry Product-Quantization codebook; PBA (Eqs. 8-10) trains a two-layer MLP to map quantized prototype embeddings into the frozen Qwen-2.5-8B prompt, maximizing likelihood on held-out responses. The reported RQ/NH/TP/RW numbers are outputs on validation/test splits, not quantities fit to redefine the result. The codebook is trained on Reddit QA and then frozen for other tasks, so the NH/TP/RW results are genuine cross-domain transfer evaluations; the fact that the codebook and the RQ evaluation share the ALIGNX source is a standard train/test separation, not a circular fit. The self-citations in the paper (Mou et al. 2024, Sun et al. 2024, Bao et al. 2024) are background citations about user simulation and role-playing agents; none is used as a load-bearing theorem or to forbid alternatives. Section 5.3.2's 'generalization' diagnostic reports codebook entry utilization counts (998, 524, 667, 743); while utilization is weak evidence of transfer because PQ assignment always selects entries by construction, this diagnostic is not the basis of the main performance claims and does not reduce a prediction to an input. The Table 1 BLEU values above 100 (108-110 on Tweet Paraphrase) are a serious evaluation-validity/correctness concern, not a circularity concern under the requested taxonomy.

Assumptions & free parameters 5 free parameters · 5 assumptions · 0 invented entities

The method is an empirical ML pipeline; the listed entries are hand-chosen hyperparameters plus domain assumptions about encoder quality, cross-domain transfer, metric validity, and privacy. No physical entities or new conserved quantities are introduced, and no parameter is fitted to redefine the central claim.

free parameters (5)

Codebook size K = 1,000
Chosen by hand in Section 3.3; ablation with CB-500/CB-2000 (Section 5.2, Figure 3c) shows moderate configurations are optimal.
Number of PQ subspaces L = 4
Chosen by hand in Section 3.3; ablation with PQ2/PQ8 (Section 5.2, Figure 3d) shows moderate configurations are optimal.
Codebook loss weights lambda1, lambda2, lambda3 = 1.0, 0.15, 1.0
Set in Appendix B; not swept, but they shape the quantization/diversity/usage balance.
History count per user J = 8
Default in Section 3.3; sensitivity tested at 2/4/8/16 in Section 5.3.3, showing relative stability.
MLP hidden dimensions = 768-3584-3584
Appendix B; determines most of the approximately 20M trainable parameters; no ablations reported.

assumptions (5)

domain assumption Frozen mean-pooled Contriever embeddings of individual behavior items capture user traits.
Sections 3.1.1 and 3.3; the encoder is never fine-tuned, so the entire signal entering the codebook and adapter is whatever Contriever mean-pooling preserves.
domain assumption An ALIGNX (Reddit) codebook transfers to news, tweet, and review domains.
Section 3.3 builds the codebook only from ALIGNX; Section 5.3.2 tests transfer only via usage counts, not generation quality.
domain assumption Prototype decomposition based on Self-Categorization Theory is a valid user model.
The introduction cites SCT to justify representing identity as blends of social prototypes; no empirical validation of the theory choice is provided.
domain assumption Discrete codebook indices are non-invertible and privacy-preserving.
Sections 5.4 and 8 assert privacy protection without inversion or membership-attack analysis.
domain assumption ROUGE/BLEU/RoBERTa similarity measure personalization quality.
Section 7 explicitly acknowledges that evaluating personalization is difficult and that LLM-as-judge was excluded; the headline numbers rely on these surface metrics.

how reviews work

0 comments

Cite this review

Pith. "Pith review of CURP: Codebook-based Continuous User Representation for Personalized Generation with LLMs." pith.science (2026). https://pith.science/paper/U4DDMUPT

@misc{pith2026260200742,
  author       = {Pith},
  title        = {Pith review of: CURP: Codebook-based Continuous User Representation for Personalized Generation with LLMs},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/U4DDMUPT}},
  note         = {Machine review of arXiv:2602.00742}
}

read the original abstract

User modeling characterizes individuals through their preferences and behavioral patterns to enable personalized simulation and generation with Large Language Models (LLMs) in contemporary approaches. However, existing methods, whether prompt-based or training-based methods, face challenges in balancing personalization quality against computational and data efficiency. We propose a novel framework CURP, which employs a bidirectional user encoder and a discrete prototype codebook to extract multi-dimensional user traits. This design enables plug-and-play personalization with a small number of trainable parameters (about 20M parameters, about 0.2\% of the total model size). Through extensive experiments on variant generation tasks, we show that CURP achieves superior performance and generalization compared to strong baselines, while offering better interpretability and scalability. The code are available at https://github.com/RaidonWong/CURP_code

Figures

Figures reproduced from arXiv: 2602.00742 by the authors.

**Figure 2.** The overall framework of our proposed CURP. Our training procedure can be divided into two stages: [PITH_FULL_IMAGE:figures/full_fig_p003_2.png] view at source ↗

**Figure 3.** (a): PQ quantization significantly reduces [PITH_FULL_IMAGE:figures/full_fig_p007_3.png] view at source ↗

Figures from the paper (1 more)

**Figure 4.** Figure 4: Analysis: The impact of history numbers. [PITH_FULL_IMAGE:figures/full_fig_p008_4.png]

Discussion (0). Sign in to comment.

Forward citations

Cited by 1 Pith paper

Reviewed papers in the Pith corpus that reference this work. Sorted by Pith novelty score. Full citation record

Large Behavior Model: A Promptable Digital Twin of the Retail Customer
cs.AI 2026-07 conditional novelty 5.0 of 10

Grounding an LLM in verbalized transaction histories via Person–Environment prompting, continued pre-training, SFT, and GRPO yields stronger retail decision simulation than frontier models, with partial cross-domain transfer.

Reference graph

Works this paper leans on

6 extracted references · 4 linked inside Pith · cited by 1 Pith paper

[1951]

Does Donald Trumpgen- uinely think

I love west- erns and this one is one of my fa- vorites. The acting is good, the story is good and the movie is well paced. I highly recommend this movie...... Description: {De- scription} Review: {Review} B Hyperparameter Settings All experiments are conducted on 8 NVIDIA A800 GPUs with a batch size of 8 per GPU. We utilize DeepSpeed ZeRO Stage 2 to enab...
[2003]

InProceedings of the 26th annual international ACM SIGIR conference on Research and development in informaion retrieval, pages 198–204

Building and applying a concept hierarchy representation of a user profile. InProceedings of the 26th annual international ACM SIGIR conference on Research and development in informaion retrieval, pages 198–204. Lin Ning, Luyang Liu, Jiaxing Wu, Neo Wu, Devora Berlowitz, Sushant Prakash, Bradley Green, Shawn O’Banion, and Jun Xie. 2025. User-llm: Efficien...

arXiv 2025
[2010]

Jihwan Jeong, Yinlam Chow, Guy Tennenholtz, Chi- hWei Hsu, Mohammad Ghavamzadeh, and Craig Boutilier

Product quantization for nearest neighbor search.IEEE transactions on pattern analysis and machine intelligence, 33(1):117–128. Jihwan Jeong, Yinlam Chow, Guy Tennenholtz, Chi- hWei Hsu, Mohammad Ghavamzadeh, and Craig Boutilier. 2024. Factual and tailored recommenda- tion endorsements using language models and rein- forcement learning. InFirst Conference...

arXiv 2024
[2015]

InProceedings of the 24th international conference on world wide web, pages 278–288

A multi-view deep learning approach for cross domain user modeling in recommendation systems. InProceedings of the 24th international conference on world wide web, pages 278–288. Ghazal Fazelnia, Eric Simon, Ian Anderson, Benjamin Carterette, and Mounia Lalmas. 2022. Variational user modeling with slow and fast features. InPro- ceedings of the Fifteenth A...

2022
[2023]

Liam Hebert, Krishna Sayana, Ambarish Jash, Alexan- dros Karatzoglou, Sukhdeep Sodhi, Sumanth Dod- dapaneni, Yanli Cai, and Dima Kuzmin

A survey on user behavior modeling in recom- mender systems.arXiv preprint arXiv:2302.11087. Liam Hebert, Krishna Sayana, Ambarish Jash, Alexan- dros Karatzoglou, Sukhdeep Sodhi, Sumanth Dod- dapaneni, Yanli Cai, and Dima Kuzmin. 2024. Per- soma: Personalized soft prompt adapter architecture for personalized language prompting.arXiv preprint arXiv:2408.00...

arXiv 2024
[2025]

Yang Deng, Wenxuan Zhang, Wai Lam, See-Kiong Ng, and Tat-Seng Chua

Onerec: Unifying retrieve and rank with gen- erative recommender and iterative preference align- ment.arXiv preprint arXiv:2502.18965. Yang Deng, Wenxuan Zhang, Wai Lam, See-Kiong Ng, and Tat-Seng Chua. 2023. Plug-and-play policy planner for large language model powered dialogue agents.arXiv preprint arXiv:2311.00262. Sumanth Doddapaneni, Krishna Sayana, ...

arXiv 2023

Pith tools

Reviewed August 3, 2026 · model on record in the stance chip above.

[1] [1951]

Does Donald Trumpgen- uinely think

I love west- erns and this one is one of my fa- vorites. The acting is good, the story is good and the movie is well paced. I highly recommend this movie...... Description: {De- scription} Review: {Review} B Hyperparameter Settings All experiments are conducted on 8 NVIDIA A800 GPUs with a batch size of 8 per GPU. We utilize DeepSpeed ZeRO Stage 2 to enab...

[2] [2003]

InProceedings of the 26th annual international ACM SIGIR conference on Research and development in informaion retrieval, pages 198–204

Building and applying a concept hierarchy representation of a user profile. InProceedings of the 26th annual international ACM SIGIR conference on Research and development in informaion retrieval, pages 198–204. Lin Ning, Luyang Liu, Jiaxing Wu, Neo Wu, Devora Berlowitz, Sushant Prakash, Bradley Green, Shawn O’Banion, and Jun Xie. 2025. User-llm: Efficien...

arXiv 2025

[3] [2010]

Jihwan Jeong, Yinlam Chow, Guy Tennenholtz, Chi- hWei Hsu, Mohammad Ghavamzadeh, and Craig Boutilier

Product quantization for nearest neighbor search.IEEE transactions on pattern analysis and machine intelligence, 33(1):117–128. Jihwan Jeong, Yinlam Chow, Guy Tennenholtz, Chi- hWei Hsu, Mohammad Ghavamzadeh, and Craig Boutilier. 2024. Factual and tailored recommenda- tion endorsements using language models and rein- forcement learning. InFirst Conference...

arXiv 2024

[4] [2015]

InProceedings of the 24th international conference on world wide web, pages 278–288

A multi-view deep learning approach for cross domain user modeling in recommendation systems. InProceedings of the 24th international conference on world wide web, pages 278–288. Ghazal Fazelnia, Eric Simon, Ian Anderson, Benjamin Carterette, and Mounia Lalmas. 2022. Variational user modeling with slow and fast features. InPro- ceedings of the Fifteenth A...

2022

[5] [2023]

Liam Hebert, Krishna Sayana, Ambarish Jash, Alexan- dros Karatzoglou, Sukhdeep Sodhi, Sumanth Dod- dapaneni, Yanli Cai, and Dima Kuzmin

A survey on user behavior modeling in recom- mender systems.arXiv preprint arXiv:2302.11087. Liam Hebert, Krishna Sayana, Ambarish Jash, Alexan- dros Karatzoglou, Sukhdeep Sodhi, Sumanth Dod- dapaneni, Yanli Cai, and Dima Kuzmin. 2024. Per- soma: Personalized soft prompt adapter architecture for personalized language prompting.arXiv preprint arXiv:2408.00...

arXiv 2024

[6] [2025]

Yang Deng, Wenxuan Zhang, Wai Lam, See-Kiong Ng, and Tat-Seng Chua

Onerec: Unifying retrieve and rank with gen- erative recommender and iterative preference align- ment.arXiv preprint arXiv:2502.18965. Yang Deng, Wenxuan Zhang, Wai Lam, See-Kiong Ng, and Tat-Seng Chua. 2023. Plug-and-play policy planner for large language model powered dialogue agents.arXiv preprint arXiv:2311.00262. Sumanth Doddapaneni, Krishna Sayana, ...

arXiv 2023