1 Introduction↩︎

Large language models (LLMs) have rapidly expanded in capability, powering applications from conversational assistants and writing tools to decision support and recommendation. Despite these advances, most LLMs remain largely preference-agnostic: they are optimized for population-level behavior and often overlook the goals, values, and writing style of a particular individual [1]–[3]. In many practical settings, however, the same request can warrant different responses for different users, motivating LLM personalization—adapting generation using user-specific information to improve usefulness and user-level alignment [4]–[6].

A dominant line of work [7]–[11] instantiates personalization through a memory–retrieval pipeline: given a user’s current query, the system retrieves relevant snippets from the user’s interaction history and concatenates them with the query as context for the LLM. While effective, real-world histories are often limited in volume and scope [12], [13] and therefore provide a partial and biased view of a user’s persona. A persona spans multiple behavioral dimensions (e.g., preferences, tone, values), but histories typically over-represent some dimensions while under-representing others (e.g., abundant signals about entertainment preferences but little about value orientation). This creates a facet-level cold-start regime [14] For instance, a user’s history might clearly indicate a preference for Sci-Fi (Genre Facet) but contain no evidence regarding their critical writing style (Tone Facet). When a query hinges on these missing dimensions, standard retrieval fails, forcing the LLM to revert to generic generation or hallucinate a persona that contradicts the user’s actual voice.

Motivated by collaborative filtering in recommendation systems [15], we investigate a collaborative remedy to this limitation: augmenting a target user’s profile by borrowing information from other users with similar behaviors. Recent work [12], [13], [16] has begun to incorporate inter-user signals for LLM personalization. However, most existing approaches [12], [13] still depend on shallow retrieval of peers’ documents under a largely global notion of similarity, offering limited structure or interpretability about which facets drive similarity and what signals should be transferred. This becomes especially problematic under sparse and skewed histories: users may appear similar overall while differing sharply by facet simply because their histories emphasize different aspects (e.g., one reveals more about communication style while another reveals more about preferences). As a result, unstructured neighbor borrowing can be noisy, difficult to control, and hard to audit.

To address this challenge, we present CoPersona, a collaborative personalization framework that incorporates persona facet structure via a facet-level similarity graph. CoPersona first discovers a small set of human-interpretable facets from population data, capturing key dimensions along which user personas vary. It then summarizes each user’s history into facet-specific profiles and embeds them to build a multiplex user–user graph, where each layer encodes similarity under a particular facet. This design provides a more interpretable and controllable mechanism for peer borrowing: it enables facet-aligned transfer, reduces negative transfer when users are similar in some dimensions but not others, and remains robust when a user’s own history is sparse or skewed toward a subset of facets.

To leverage peer information effectively at inference time, CoPersona combines two complementary components. (i) A lightweight non-parametric branch retrieves facet-aligned neighbor profiles to provide transparent, human-readable evidence that can be directly inspected in the prompt. Using prompt-based evidence alone can result in performance limitation under context-length and noise constraints: relevant peer signals may be sparse, redundant, or difficult for the LLM to integrate consistently. (ii) A complementary parametric graph branch performs reliability-gated message passing over the multiplex facet relationship graph, aggregating neighbor information in latent space to complement under-supported facets and compressing the result into soft-prompt tokens. Together, these components mitigate facet coverage bias and improve personalization when user histories are sparse or uneven. Experiments across multiple domains and model scales show consistent gains over strong baselines, validating CoPersona as a practical approach to robust LLM personalization via graph-based peer borrowing. In summary, our contributions are:

• We propose CoPersona, which discovers persona facets, constructs a facet-level multiplex similarity graph, and enables inference-time graph-based collaborative information borrowing.

• We develop a dual-branch inference mechanism—(i) facet-aligned neighbor retrieval in text space and (ii) reliability-gated graph aggregation in latent space—that robustly complements missing or weakly observed facets.

• We demonstrate consistent gains across domains and model scales, validating CoPersona as a practical approach to robust LLM personalization.

2 Preliminaries↩︎

2.1 Problem Formulation↩︎

LLM personalization aims to generate user-aligned text by leveraging a user’s historical interactions. Let \(\mathcal{U}=\{u_1,\ldots,u_N\}\) denote users. For each user \(u\), we observe a history \(\mathcal{D}_u=\{(x_k,y_k)\}_{k=1}^{N_u}\), where each pair corresponds to one interaction. Here \(x\) is the input context that specifies what to respond to (e.g., an item title/category/short description for review generation, or an incoming email/dialogue history for assistant-style tasks). The target \(y\) is the user-authored text response (e.g., a critical vs.enthusiastic review, a terse vs.detailed reply), which implicitly reflects the user’s preferences and writing style.

Standard methods assume that the observed history \(\mathcal{D}_u\) is a sufficient statistic to model the user’s behavior. They learn parameters \(\theta\) of a conditional model \(P_\theta\) by maximizing the likelihood of observed responses given queries and the user’s history: \[\theta^\star=\underset{\theta}{\operatorname{argmax}} \sum_{(x,y)\in \mathcal{T}_u} \log P_\theta\left(y \mid x, \mathcal{D}_u\right),\] where \(\mathcal{T}_u\) denotes training examples for user \(u\) (or a population-level training set with user histories).

2.2 Facet Coverage Bias↩︎

In reality, user personas are inherently multi-faceted rather than monolithic: a single user may vary along multiple latent behavioral dimensions (e.g., topical preferences, value orientation, tone, and stylistic habits), and different generation contexts can selectively elicit different dimensions. Following [17], [18], we view each user as governed by a set of latent facets that jointly shape their outputs.

Concretely, let \(\mathcal{F}=\{f_m\}_{m=1}^{M}\) denote a global facet schema. For each user \(u\), we associate a latent persona state \(Z_u=\{z_u^{(m)}\}_{m=1}^{M}\), where \(z_u^{(m)}\) captures how user \(u\) behaves along facet \(f_m\). We observe only a finite interaction history \(D_u=\{(x_k,y_k)\}_{k=1}^{N_u}\), where each interaction provides partial and context-dependent evidence about \(Z_u\). Importantly, the history is rarely uniformly informative across facets [19], [20]: some facets are repeatedly surfaced by the user’s logged contexts (e.g., consistent formality and analytical style in product reviews), while other facets (e.g., humor usage, emotional expressiveness, or conversational warmth) may be sparsely exhibited or never elicited.

We refer to this uneven observability as Facet Coverage Bias: the empirical distribution of evidence in \(D_u\) is skewed toward a subset of facets, yielding low coverage for the remainder. Low coverage should be interpreted as under-observation rather than absence [19], [20]—a facet can be part of the user’s true persona yet remain weakly supported in the recorded log. This perspective is consistent with prior findings that observational user traces are selective and incomplete, where non-observation does not imply non-preference or non-existence.

Facet coverage bias becomes problematic at test time when the new query \(x'\) implicitly requires facets that are weakly supported in \(D_u\). In this regime, standard personalization methods (retrieval-, profile-, or embedding-based) tend to extrapolate from the dominant observed facets, causing over-transfer: the model produces outputs that are faithful to what is well-covered in the history (e.g., persistent formality) but misaligned with the facet(s) that the current request actually hinges on (e.g., a more playful, empathetic, or persuasive tone). In Sec. 4.3, we empirically quantify this coverage skew and show that performance degradation concentrates on under-covered facets, motivating our facet-aware collaborative completion strategy.

3 Methodology↩︎

To mitigate Facet Coverage Bias arising from isolated and often sparse user histories, we propose CoPersona, a framework that casts LLM personalization as graph-based collaborative inference. The core insight is that, although any single user’s history may be limited, population-level behavior is comparatively dense and structured: users who align on observed facets (e.g., value orientation) are more likely to share unobserved facets (e.g., genre preference). Accordingly, instead of restricting personalization for user \(u\) to their own history \(\mathcal{D}_u\), CoPersona models the population manifold as a Collaborative Persona Graph \(\mathcal{G}\)—a multiplex user–user similarity graph where each facet induces a similarity layer connecting semantically aligned users. This graph acts as a semantic bridge that enables a target user to “borrow” complementary signals from similar peers to complete their latent persona for downstream generation. Formally, we expand the probabilistic generation model to condition on \(\mathcal{G}\): \[P_\theta\!\left(y' \mid x', \mathcal{D}_u, \mathcal{G}\right),\] from which a response is produced via a decoding strategy (e.g., sampling or beam search). CoPersona instantiates this formulation in three phases: (1) Facet Disentanglement (Sec. 3.1), which structures raw histories into facet-specific summaries and embeddings; (2) Multiplex Graph Construction (Sec. 3.2), which maps inter-user per-facet relations; and (3) Dual-Branch Inference (Sec. 3.3), which jointly leverages parametric reasoning and non-parametric context retrieval.

3.1 Facet Disentanglement↩︎

User personas are inherently multi-faceted, yet real-world histories are sparse and skewed: only a few behavioral attributes are repeatedly expressed, while others are rarely elicited. CoPersona therefore disentangles a user’s history into facet-specific representations in two steps: we first induce a compact global facet schema in a data-driven manner, then summarize and embed each user per facet to obtain a structured persona state.

3.1.0.1 Facet schema induction.

A key design choice is to avoid a manually pre-defined facet list. Predefining facets is brittle: the “right” schema is domain- and population-dependent, hard to enumerate exhaustively, and easy to miss emergent behavioral axes that matter for downstream generation. Instead, we induce facets from population data so the schema (i) adapts to the dataset’s dominant modes of variation, (ii) remains human-interpretable, and (iii) provides consistent organizing dimensions for facet-aware similarity and collaboration.

Concretely, we first construct a profile text \(\tau_u\) for each user by concatenating up to \(R\) historical interactions. We encode \(\tau_u\) with a sentence encoder to obtain a dense profile embedding \(z_u \in \mathbb{R}^d\), and cluster \(\{z_u\}\) into \(K\) groups using standard clustering algorithm (e.g., KMeans or HDBSCAN) to identify representative persona modes.

For each cluster \(k\), we select a small set of prototype users and build a compact evidence package \(S_k = (T_k, E_k)\) where \(T_k\) is a set of cluster-level keywords/phrases summarizing salient cues (i.e. top TF-IDF terms computed over \(\{\tau_u : u \in \text{Cluster }k\}\)), and \({E}_k\) is a small set of representative evidence (e.g., short excerpts) collected from users in cluster \(k\).

Collecting these packages as \(P=\{S_k\}_{k=1}^{K}\), we prompt an LLM to contrast clusters and induce a facet schema whose axes best separate the representative persona modes: \[\hat{\mathcal{F}}=\{f_m\}_{m=1}^{M} = \operatorname{LLM}{({P})},\] where each facet \(f_m\) includes (i) a concise name, (ii) a natural-language definition describing the behavioral attribute, and (iii) a scoring specification (categorical or ordinal) to clarify how evidence should be interpreted. We further instruct the LLM to avoid redundant facets and prefer orthogonal dimensions (e.g., tone vs.topical preference vs.value orientation), yielding a small, interpretable schema that is shared across users and serves as the organizing backbone for downstream per-facet summarization and facet-wise similarity modeling.

3.1.0.2 Facet summarization, reliability, and embeddings.

Given the induced schema \(\mathcal{F}\), we derive facet-specific summarization and representations for every user. For each user \(u\) and facet \(m\), we gather the set of historical interactions and prompt an LLM to produce: (i) a concise facet summary \(s_u^{(m)}\) describing the user’s typical behavior along the facet dimension \(f_m\) (e.g., value orientation), (ii) optionally up to two short supporting quotes \(\mathrm{ev}_u^{(m)}\) grounded in the user’s past text, and (iii) a reliability label \(r_u^{(m)} \in \{\texttt{none}, \texttt{weak}, \texttt{moderate}, \texttt{strong}\}\) that indicates how well the facet summary is supported by available evidence. We form the facet description by concatenation: \[t_u^{(m)} = [\, s_u^{(m)} ; \mathrm{ev}_u^{(m)} \,].\] We then embed \(t_u^{(m)}\) with a pretrained sentence encoder and \(\ell_2\) normalization to obtain a dense per-facet embedding \(e_u^{(m)} \in \mathbb{R}^d\). For facets with little or no usable evidence (typically \(r_u^{(m)}\in\{\texttt{none},\texttt{weak}\}\)), we instantiate a neutral placeholder description (e.g., “No explicit profile information provided.”) before encoding, ensuring every user has a well-formed representation on every facet. The resulting embeddings \(\{e_u^{(m)}\}_{m=1}^M\), together with reliability labels \(\{r_u^{(m)}\}_{m=1}^M\), constitute a disentangled persona state; in later stages, the reliability signal is used to downweight or filter low-support facets when constructing facet-wise neighborhoods and performing collaborative inference.

3.2 Multiplex Collaborative Persona Graph↩︎

Given the facet-level decomposition from Sec. 3.1, we construct a multiplex Collaborative Persona Graph \(\mathcal{G}\) that organizes users by their similarity within each facet. Concretely, \(\mathcal{G}\) contains \(M\) facet-induced layers, one per facet \(m\in\{1,\dots,M\}\) in the induced schema \(\mathcal{F}\). Each layer shares the same node set \(\mathcal{V}\) (one node per user), but has its own edge set capturing facet-specific peer alignment. This multiplex structure provides the backbone for controlled, facet-aware collaboration: it allows CoPersona to borrow complementary signals from peers on the particular facet that is under-observed for the target user, rather than collapsing all evidence into a single global similarity score.

3.2.0.1 Nodes and facet states.

For every user \(u\) and facet \(m\), Sec. 3.1 produces a normalized facet embedding \(\mathbf{e}_u^{(m)}\in\mathbb{R}^d\) together with a reliability label \(r_u^{(m)} \in \{\texttt{none},\texttt{weak},\texttt{moderate},\texttt{strong}\}\) indicating how well the facet summary is supported by the user history. We use \(\{\mathbf{e}_u^{(m)}\}_{u\in\mathcal{V}}\) as the node embedding table for layer \(m\), and leverage \(\{r_u^{(m)}\}\) to downweight or filter low-evidence facets when forming neighborhoods.

3.2.0.2 Facet-wise edges and sparsification.

Edges are defined independently within each facet layer. In layer \(m\), we compute the cosine similarity between users \(u\) and \(v\) using their normalized facet embeddings: \[\label{eq:sim951} \mathbf{A}_{uv}^{(m)} = \text{sim}(\mathbf{e}_u^{(m)}, \mathbf{e}_v^{(m)}) = \frac{\mathbf{e}_u^{(m)} \cdot \mathbf{e}_v^{(m)}}{\|\mathbf{e}_u^{(m)}\| \|\mathbf{e}_v^{(m)}\|}.\tag{1}\] To incorporate evidence quality, we optionally apply a reliability gate to the similarity by multiplying by a scalar weight \(\omega(\cdot)\) (Details in Appendix. 8): \[\label{eq:sim952} \tilde{\mathbf{A}}_{uv}^{(m)} \;=\; \omega\!\left(r_u^{(m)}\right)\,\omega\!\left(r_v^{(m)}\right)\,\mathbf{A}_{uv}^{(m)},\tag{2}\] where \(\omega(\texttt{none}) \le \omega(\texttt{weak}) \le \omega(\texttt{moderate}) \le \omega(\texttt{strong})\). Finally, to reduce noise and ensure scalability, we sparsify each layer by retaining only the top-\(K\) neighbors per user under \(\tilde{\mathbf{A}}^{(m)}\), yielding facet-specific neighborhoods \(\mathcal{N}_u^{(m)}\) and a sparse adjacency per layer.

Under this multiplex construction, when a target user under-expresses a facet \(m\) (low \(r_u^{(m)}\)), CoPersona can still identify a set of aligned peers using other facets \(m' \neq m\) that are well-supported for the user (high \(r_u^{(m')}\)). This allows CoPersona to implicitly infer facet \(m\) by aggregating these peers’ facet-\(m\) representations.

3.3 Dual-Branch Inference↩︎

CoPersona combines two complementary inference mechanisms. The non-parametric branch retrieves facet-specific exemplars from behaviorally similar users, preserving human-interpretable signals in observed facets. The parametric branch performs latent collaborative inference on the Collaborative Persona Graph, using reliability-gated message passing to denoise observed facets and impute missing ones in a continuous embedding space. At inference time, both branches contribute conditioning signals to the base LLM: retrieved exemplars are provided as textual context, while the collaborative persona embedding is injected as soft prompts.

3.3.0.1 Non-Parametric Facet Retrieval

The first branch of CoPersona implements a non-parametric, retrieval-style form of personalization that operates directly in the text space by reusing the facet-wise neighborhoods of the multiplex Collaborative Persona Graph (Sec. 3.2). In facet layer \(m\), edges are weighted by the reliability-gated facet similarity \(\tilde{A}_{u v}^{(m)}\) derived from cosine similarity of facet embeddings (Eq. 1 and Eq. 2 ).

For a target user \(u^{\star}\) and facet \(m\), we retrieve neighbors directly from the sparsified graph: \[{N}_{u^{\star}}^{(m)}=\left\{v \mid\left(u^{\star}, v\right) \in \mathcal{E}^{(m)}\right\},\] where \(\mathcal{E}^{(m)}\) retains the top- \(K\) neighbors per user under \(\tilde{A}^{(m)}\). (Equivalently, \({N}_{u^{\star}}^{(m)}\) matches the TopK set under \(\tilde{A}_{u^{\star} v}^{(m)}\); we use the stored neighborhood for efficiency and consistency.)

From each neighbor \(v \in N^{(m)}_{u^\star}\), we retrieve a facet-aligned exemplar package \(t^{(m)}_v = [s^{(m)}_v; ev^{(m)}_v]\) (Eq. 4), which includes the neighbor’s facet summary and (when available) short evidence quotes grounded in their past text.

We then form the facet-wise exemplar set: \[E^{(m)}_{u^\star} = \left\{ \bigl(v,\; t^{(m)}_v,\; \tilde{A}^{(m)}_{u^\star v}\bigr)\;\middle|\; v \in N^{(m)}_{u^\star} \right\}.\]

Finally, we linearize \(\{E^{(m)}_{u^\star}\}_{m=1}^M\) into a facet-grouped peer context \(C^{\text{peer}}_{u^\star}\), where \(\tilde{A}^{(m)}_{u^\star v}\) serves as an explicit confidence signal over retrieved peer exemplars. This branch makes no parametric updates and preserves facet-aligned, human-interpretable peer signals.

3.3.0.2 Parametric Graph Reasoning

While the non-parametric branch can already supply useful signals for under-observed facets by retrieving facet-specific exemplars from similar users, it does so in an explicitly local and token-level manner, and its effectiveness is constrained by retrieval noise and context length. The parametric branch of CoPersona is designed as a complementary mechanism: instead of operating on raw text, it performs latent collaborative inference over the Collaborative Persona Graph via a reliability-gated message passing scheme, aggregating information from neighbors into continuous facet representations and learning how strongly to trust self versus peers. This yields smoothed, reliability-aware facet embeddings that provide a compact soft-prompt prior, complementing the discrete, example-based guidance from the non-parametric branch.

We start from the facet-specific embeddings \(\mathbf{e}_u^{(m)}\) and the ordinal reliability label \(r_u^{(m)} \in\) introduced in Sec. 3.1, and use it to control how strongly the parametric branch trusts the user’s own facet representation versus information aggregated from neighbors. Concretely, we transform the discrete label into a scalar trust gate \(\gamma_u^{(m)}=f_\theta\left(r_u^{(m)}\right) \in[0,1]\) using a learnable monotone scoring function \(f_\theta(\cdot)\)¹, . This yields a monotonically increasing confidence score aligned with evidence strength, and \(\gamma_u^{(m)}\) is then used in the reliability-gated message passing update to interpolate between the user’s own facet embedding and the neighbor-aggregated embedding, with larger \(\gamma_u^{(m)}\) placing more weight on self and smaller values relying more on peers.

To exploit cross-user structure, we construct a shared neighbor set \(\mathcal{N}_u\) at the user level (e.g., from an anchor embedding that aggregates the observed facets of \(u\)). Intuitively, \(\mathcal{N}_u\) contains users whose overall persona profiles are structurally similar, even if individual facets may be missing for \(u\). For each facet \(m\), we initialize the node state with the facet embedding, \[\mathbf{h}_u^{(0,m)} = \mathbf{e}_u^{(m)},\] and aggregate facet-\(m\) information from the neighbors of \(u\): \[\tilde{\mathbf{h}}_u^{(m)} = \mathrm{Agg}_{v \in \mathcal{N}_u} \mathbf{h}_v^{(0,m)},\] where \(\mathrm{Agg}\) is a permutation-invariant operator (e.g., mean). We then apply a reliability-aware, self-vs-neighbors gate to obtain the updated facet representation: \[\mathbf{h}_u^{(m)} = \sigma\!\Big( W \big( \gamma_u^{(m)} \,\mathbf{h}_u^{(0,m)} + (1 - \gamma_u^{(m)}) \,\tilde{\mathbf{h}}_u^{(m)} \big) \Big),\] with \(W\) a shared projection and \(\sigma\) a nonlinearity. When facet \(m\) is strongly supported for user \(u\) (\(\gamma_u^{(m)}\approx 1\)), the update is dominated by the user’s own facet embedding and only lightly influenced by neighbors. When the LLM indicates that facet \(m\) is weak or absent for \(u\) (\(\gamma_u^{(m)}\approx 0\)), the update leans toward the aggregated neighbor embedding, effectively imputing the missing facet from structurally similar peers.

The resulting set \(\{\mathbf{h}_u^{(m)}\}_{m=1}^M\) forms a latent, collaboratively smoothed view of the user’s persona. To capture semantic dependencies between these behavioral dimensions, we apply a cross-facet self-attention mechanism over the facet embeddings after each layer. We finally concatenate these contextualized embeddings to obtain a single collaborative persona vector \(\mathbf{h}_u\): \[\mathbf{h}_u = \big[ {\mathbf{h}}_u^{(1)} \mathbin{\|} \dots \mathbin{\|} {\mathbf{h}}_u^{(M)} \big].\] This vector is then projected into a fixed number of soft prompt tokens that condition the base LLM during generation. In contrast to the non-parametric branch, which operates in the space of retrieved exemplars, the parametric branch performs inference in a latent space over the graph, denoising observed facets and inferring plausible values for under-observed ones.

3.4 Joint Optimization↩︎

During training, we optimize all learnable components of CoPersona jointly with the base LLM. For each user \(u\) and query \(x'\), the parametric branch produces a collaborative persona vector \(\mathbf{h}_u\) from the reliability-gated graph reasoning in Sec. 3.3.0.2. We map this vector into a fixed-length sequence of soft prompt tokens by a learned linear projection: \[\mathbf{S}_u = \mathrm{reshape}\big(W_p \mathbf{h}_u\big) \in \mathbb{R}^{L_p \times d_{\text{LLM}}},\] where \(W_p \in \mathbb{R}^{(L_p \cdot d_{\text{LLM}}) \times d_{\text{persona}}}\) is a trainable matrix, \(L_p\) is the number of soft prompt tokens, \(d_{\text{LLM}}\) is the hidden dimension of the base LLM, and \(\mathrm{reshape}(\cdot)\) converts the projected vector into a matrix of \(L_p\) token embeddings.

In parallel, we retrieve query-relevant interactions from the target user’s own history via BM25 [21], following [16]. Let \(\mathcal{H}_u(x') = \mathrm{\small BM25TopK}(x', \mathcal{D}_u)\) denote the retrieved self-history. We combine this with the peer exemplar context from the non-parametric branch to form the textual conditioning: \(C_u(x') = \mathrm{\small Linearize}\big(\mathcal{H}_u(x'), \{E^{(m)}_u\}_{m=1}^M \big).\)

The final input to the LLM is the concatenation, in embedding space, of the soft prompts \(\mathbf{S}_u\), the retrieved context \(C_u(x')\), and the current query \(x'\). We train by minimizing the negative log-likelihood of \(y\): \[\mathcal{L} = - \sum_{t=1}^{|y|} \log P_{\mathrm{LLM}}\!\left(y_t \mid y_{<t},\, \mathbf{S}_u,\, C_u(x'),\, x'\right).\]

4 Experimental Results↩︎

4pt

4pt

We conduct experiments on real-world personalization benchmarks to answer the following research questions:

• RQ1: How does CoPersona compare with existing personalization baselines in overall generation quality and user alignment?

• RQ2: Do the reviews generated by CoPersona appear more human-like and authentic, as assessed by LLM-as-Judge evaluation?

• RQ3: How much does each component of CoPersona contribute to performance (e.g., the parametric branch, the non-parametric branch, and the retrieval strategy)?

• RQ4: How robust is CoPersona to key design choices (e.g., the number of facets and neighbors), and how sensitive is it to major hyperparameters (e.g., decoding temperature)?

4.1 Experimental Setup↩︎

Datasets. Building upon prior work, we focus on the representative task of review generation for LLM personalization [8], [16], [22]–[26]. Specifically, we adopt the Amazon Reviews 2023 dataset² [23] , as used by DEP [22], covering three categories: Books, Movies & TV, and CDs & Vinyl. In addition, we construct three more category-specific datasets from Amazon Reviews 2023 by applying the DPL preprocessing pipeline [16] to Video Games, Musical Instruments, and Sports & Outdoors. These categories exhibit sparser user–item interactions, allowing us to better assess generalization under limited history. We intentionally filter the data to ensure that each user retains only a limited number of reviews, thereby maintaining sparsity. For all six datasets, we follow the original test splits provided by DPL [16]. More details about the datasets are provided in Appendix 6.

Baselines. Following existing personalization works such as DPL [16] and DEP [22], We compare CoPersona with the following baseline methods (implementation details in Appendix 7. For some baselines, we also report results using a larger 32B base model.

• Non-Perso: Generates reviews using only item information, titles, and ratings, without user personalization.

• RAG [7]: Conditions generation on retrieved user history records for contextual personalization.

• PAG [9]: Summarizes user history into a compact profile and combines it with retrieved evidence for structured personalization.

• DPL [16]: Builds a textual user profile by contrasting the target user with similar peers and prepends it to the prompt.

• DEP [22]: Learns user embeddings that capture preference differences and injects them into a frozen LLM as soft conditioning signals.

Evaluation Metrics. Following previous works on personalized text generation [7], [8], [16], [22], [25]–[27], we report ROUGE-1 [28], ROUGE-L [28], METEOR [29], BLEU³ [31], and BERTScore⁴ [33].

In addition, we report LLM-as-Judge evaluation to assess the human-likeness of generated reviews beyond n-gram overlap. Unlike BLEU/ROUGE, which capture surface similarity, LLM-as-Judge directly evaluates naturalness and authenticity, providing a scalable proxy for whether reviews sound genuinely human [34].

Implementation Details. We build facet-specific user profiles by summarizing up to six reviews with GPT-4o-mini  [35] and embedding them using sentence-transformers/all-mpnet-base-v2 [36], [37]. We then construct a multiplex user graph where facet-wise cosine similarities select up to five neighbors and are averaged for a combined score. Personalization is achieved on Qwen/Qwen2.5-7B-Instruct [38] via a soft-prompt and LoRA  [39] finetuning. At inference, cached soft prompts are used with BM25  [21]-retrieved history. Additional details are provided in Appendix 8.

4.2 Main Results (RQ1 & RQ2)↩︎

Table 1 reports performance on three benchmark categories. CoPersona consistently achieves the best results across all metrics and datasets. On Books, our method surpasses the strongest baseline (DEP) by +3.3 ROUGE-1, +3.4 METEOR, and +3.1 BLEU, indicating substantially better lexical alignment and semantic fidelity. Similar gains are observed on Movies & TV and CDs & Vinyl, where CoPersona yields the highest ROUGE, METEOR, BLEU, and BERTScore simultaneously.

Notably, while prior methods such as RAG, PAG, and DPL improve over non-personalized generation, their gains remain limited under sparse histories. In contrast, CoPersona’s collaborative persona completion provides complementary facet evidence, leading to more accurate and consistent improvements.

4.2.0.1 Generalization to Sparse Settings.

Results on Video Games, Musical Instruments, and Sports & Outdoors further confirm the robustness of CoPersona, as these datasets are particularly preprocessed to mimic the cold start settings (Section 4.1). Our method achieves the highest ROUGE-1, ROUGE-L, and BLEU across all three categories. In Video Games and Sports & Outdoors, CoPersona delivers particularly strong BLEU gains, suggesting improved phrase-level alignment and stylistic consistency.

Although PAG and DPL occasionally yield competitive METEOR scores, they do not consistently outperform CoPersona across metrics. This demonstrates that collaborative facet borrowing generalizes beyond the core domains and remains effective across diverse product categories.

4.2.0.2 LLM-as-Judge Evaluation

Table 3 presents human-likeness scores evaluated by Qwen2.5-72B-Instruct-AWQ [38], [40]. CoPersona achieves the highest or tied-highest scores across all evaluated dimensions, indicating that its generated reviews appear more natural and authentic. Due to limited context window constraints, LLM-as-Judge evaluation is performed only on the Books dataset⁵.

4pt

Quantitatively, CoPersona consistently outperforms the strongest baseline, DEP, with a notable gain of \(+1.24\) in Practical Details. These results demonstrate that collaborative facet completion significantly enhances writing realism and perceived authenticity, confirming that the model’s improvements extend beyond mere n-gram overlap.

4.3 Facet Coverage Bias Analysis↩︎

We numerically evaluate facet coverage bias in the existing dataset. Table 4 reports the per-domain statistics and the fraction of facet-biased samples, defined as users for which at least one facet has support no stronger than moderate (Sec. 3.1). A higher fraction therefore indicates more severe facet coverage bias (i.e., weaker facet coverage in user histories). We find that this bias is pervasive across domains: Movies & TV exhibits the highest bias rate (100%), followed by Books (97.48%), while CDs & Vinyl shows a comparatively lower—though still substantial—rate (88.26%). This suggests domain-dependent evidence sparsity: in Movies & TV and Books, nearly all users have at least one facet that is not strongly supported, making the induced profiles more prone to bias from incomplete, diffuse, or noisy support signals.

4.4 Ablation Studies (RQ3)↩︎

We ablate key components of CoPersona to quantify where its gains come from. Unless otherwise stated, we report results on Books and keep the training setup and decoding strategy fixed.

4.4.0.1 Dual-branch inference.

Table 5 shows that both branches contribute, with the parametric graph branch playing a larger role. Removing the non-parametric branch drops performance from 0.3953 to 0.3822 in ROUGE-1 and from 15.47 to 13.30 in BLEU, indicating that facet-aligned neighbor exemplars provide useful, human-readable evidence beyond the user’s own sparse history. Removing the parametric branch causes a substantially larger degradation (ROUGE-1 0.3673; BLEU 11.34), suggesting that latent graph reasoning is crucial for denoising and completing weakly supported facets under facet coverage bias. Overall, the best performance is achieved when both branches are combined, validating the complementarity between text-space neighbor evidence and latent-space collaborative refinement.

4.4.0.2 Retrieval strategy for self-history.

We further examine the impact of the self-history retrieval module by replacing the default BM25 [21] retriever with a dense retriever, Contriever [41]. This substitution leads to a small but consistent decrease in performance (e.g., ROUGE-1 0.3906 vs.), suggesting that the gains of CoPersona are not driven by a particular retriever and that the collaborative signal remains effective under alternative retrieval backends. Interestingly, a simple recency-based heuristic attains the best results on Books, likely because recent interactions better capture a user’s current writing style and preferences. Nevertheless, to enable fair comparison with prior work that uses BM25 as the default retriever (e.g., [16]), we adopt BM25 as the main system configuration throughout our experiments.

4pt

4.5 Hyperparameter Sensitivity (RQ4)↩︎

We examine robustness to several key design choices on Books.

4.5.0.1 Decoding temperature.

Figure 3 varies the decoding temperature over a broad range (0.5–1.0). Performance is largely stable in the range 0.7–1.0, with a mild peak at moderate temperatures, indicating that CoPersona does not require careful tuning of sampling stochasticity to maintain strong quality. Following prior work [22], we use a default temperature of 0.8 in all experiments.

4.5.0.2 Number of induced facets.

Figure 4 varies the size of the induced facet schema (3–6). We observe a gradual improvement as the number of facets increases, consistent with the intuition that a more fine-grained schema better decomposes a user’s persona and reduces facet mixing when evidence is uneven. At the same time, gains diminish beyond a moderate number of facets, suggesting that CoPersona benefits from finer structure but does not rely on an aggressively large schema.

4.5.0.3 Retrieved neighbor budget.

Figure 5 varies the number of retrieved neighbors (0–3). Performance improves steadily as we retrieve more neighbors, indicating that additional peer evidence provides complementary signals that help complete under-supported facets. The improvement saturates at larger budgets, implying that only a small but related neighborhood is sufficient to capture most of the collaborative benefit while keeping inference efficient.

4.6 Discovered Facet Schema↩︎

To better understand the personas induced by CoPersona , we present the facets discovered across domains (Table 6). The induced schemas vary by dataset and reflect domain-specific user concerns: in narrative domains such as Books and Movies, facets often capture emotional engagement and critical interpretation, whereas in product-centric domains such as Sports & Outdoors and Musical Instruments, they emphasize utility-oriented considerations (e.g., value for money, product quality, and usage context). Overall, these patterns suggest that our facet discovery adapts to domain signals and yields interpretable preference dimensions for personalization, rather than dataset-agnostic latent factors.

5pt

5 Related Work↩︎

5.0.0.1 Personalization in LLMs.

LLM personalization seeks to adapt model behavior to individual users’ preferences, goals, and interaction patterns [7]. Prior work generally falls into two broad paradigms: prompting-based methods and finetuning-based techniques. Early prompting-based approaches [42], [43] encode user information directly in the input, using structured or unstructured natural language prompts to summarize preferences or interaction history, but they rely heavily on careful prompt construction and aggressive compression of user data [44], [45]. More recent work [6]–[8], [46]–[50] adopts retrieval-augmented strategies that dynamically incorporate relevant signals from a user’s past interactions into the model context at inference time, alleviating context-length constraints while remaining vulnerable to retrieval errors, particularly when user histories are sparse or noisy. Finetuning-based approaches, including soft-prompt [51], [52], LoRA [53]–[56], and RLHF-style [57]–[62] finetuning, offer an alternative by embedding user-specific information directly into model parameters, enabling more efficient and persistent personalization. However, these works are typically limited to capturing single user’s information.

5.0.0.2 Cold-Start Problem and Collaborative Filtering.

The cold-start problem, long studied in recommendation systems, arises when limited interaction data prevents accurate preference modeling for new users [14], [63]. Common solutions include leveraging side information [64], and collaborative filtering [15], which mitigates sparsity by transferring signals from similar users. Inspired by this paradigm, recent work extends collaborative filtering to LLM personalization by incorporating inter-user information. One line of work explicitly models user–peer differences, using natural-language summaries or difference-aware latent soft prompts [16], [22]. Other approaches go further by directly injecting peer interactions into prompts or constructing shared persona representations [12], [13], [65]. However, they typically rely on global similarity in an unstructured space and perform only shallow retrieval over peers’ histories [13]. In contrast, our approach adopts a structured, facet-aware framework: we construct a multiplex facet-level graph and borrow signals from neighbors aligned on specific facets via both non-parametric retrieval and parametric message passing, enabling targeted transfer rather than indiscriminate peer aggregation.

6 Overview of Datasets↩︎

We study personalized review generation using Amazon Reviews 2023 [23] following the DPL preprocessing protocol [16]. Besides the original DPL splits, we construct three additional categories (Video Games, Sports & Outdoors, Musical Instruments) with adjusted thresholds to better simulate sparse-user settings.

6.0.0.1 Preprocessing

We filter reviews to keep only entries with valid text, title, rating, and timestamp above a minimum length. Items are kept if their cleaned descriptions fall within a length range and have valid metadata. We then iteratively prune the user–item graph so that: (i) each item has at least a minimum number of reviewers, and (ii) each user has a minimum number of reviews. Duplicate reviews are removed by keeping the most recent unique (user, item) interaction.

6.0.0.2 Profile Construction

For each user, reviews are sorted chronologically. The most recent \(k=2\) interactions are held out as targets (bounded by at most half of the history). Earlier interactions form the profile. Users with too few profile reviews and items appearing in too few profiles are further pruned.

6.0.0.3 Splits

Given a profile and held-out interactions:

• Train: predict earlier held-out reviews autoregressively,

• Validation: predict the second-to-last review,

• Test: predict the last review.

6.0.0.4 Data Format

Each instance contains a user ID, profile reviews, and a target review:

{user_id, profile: [reviews...], data: target_review}

Each input concatenates target item title, description, review title, rating, and retrieved user history.

7 Baseline Details↩︎

We compare CoPersona with representative personalization baselines that differ in how user information is represented and incorporated into generation.

• Non-Perso. This baseline removes personalization signals and conditions the LLM only on item-level inputs, the target rating, and the review title. It serves as a lower bound for generation without user history.

• RAG [7]. RAG retrieves a small set of the user’s recent reviews and concatenates them into the prompt, allowing the LLM to infer preferences directly from raw historical examples.

• PAG [9]. PAG summarizes recent reviews into a natural-language user profile and provides it together with retrieved reviews, combining high-level preferences with concrete evidence.

• DPL [16]. DPL constructs a difference-aware profile by comparing the target user with representative users selected through embedding-space clustering. The resulting summary captures differences in aspects such as sentiment, topics, and style, and is prepended to the generation prompt. For fairness, we use the same embedding model as in CoPersona for representative-user selection.

• DEP [22]. DEP learns latent user embeddings that capture preference deviations from other users and injects the resulting personalization vectors into a frozen LLM as soft prompts, enabling representation-level personalization without increasing prompt length.

8 Implementation Details↩︎

8.0.0.1 Facet Disentanglement.

We implement a two-stage pipeline for persona facet discovery. First, we construct a user-level document by concatenating up to 8 recent reviews per user (including rating, title, and text) and truncating to a fixed length for stability. We encode each user document using a SentenceTransformer encoder (all-MiniLM-L6-v2) with \(\ell_2\)-normalized embeddings [36]. We augment semantic embeddings with lightweight writing-style features (e.g., average review length, sentence-length proxy, punctuation/emoji rate, lexical diversity, and rating statistics), which are standardized and concatenated to the embedding vector. We then cluster users using KMeans [66], and for each cluster, we compute representative keywords via TF–IDF [67] and select representative users via medoid-based selection using cosine distance. Finally, we pack cluster summaries (cluster size, top terms, representative excerpts, and style statistics) and prompt an LLM to induce a small, non-redundant set of human-interpretable facets, each with a definition, value specification, scoring rubric, and evidence grounded in specific clusters; the model returns a structured facet schema in JSON for downstream personalization. For efficient local inference, we support vLLM [68] as the backend.

8.0.0.2 Facet summarization and per-facet embeddings.

We start from a discovered facet set. For each user, we summarize up to 6 historical reviews into facet-specific profile text using gpt-4o-mini [35], with temperature 0.2 and a 2048-token budget, batching 8 users per LLM call. We then embed each facet summary with sentence-transformers/all-mpnet-base-v2 [36], [37].⁶ Embeddings are computed with max sequence length 512, batch size 32, and L2 normalization. Each per-user facet embedding concatenates the facet paragraph with up to two evidence quotes when available.

8.0.0.3 Multiplex user–user similarity graph.

We construct a multiplex graph where each facet induces a similarity layer. For each facet, we compute cosine similarity (dot product of normalized embeddings), retain up to 5 neighbors per facet with similarity \(\ge 0.35\), and store the facet-specific similarity as an edge weight. A user pair’s combined similarity is defined as the mean of its facet weights. We use fixed reliability weights \(\boldsymbol{\omega}=[0.05,\,0.25,\,0.60,\,0.95]\) in graph construction stage, corresponding to \(r\in[\texttt{none},\,\texttt{weak},\,\texttt{moderate},\,\texttt{strong}]\), respectively.

8.0.0.4 Monotone label-to-gate mapping.

In learnable parametric branch, we convert the ordinal reliability label \(r_u^{(m)} \in\{\) none, weak, moderate, strong \(\}\) into a scalar trust gate \(\gamma_u^{(m)} \in[0,1]\) via a lightweight learnable mapping. Let \(\ell(r) \in\{0,1,2,3\}\) denote the ordinal encoding of the label. We learn a gate value \(\left\{\gamma_k\right\}_{k=0}^3\) for each label level and set \(\gamma_u^{(m)}=\gamma_{\ell\left(r_u^{(m)}\right)}\). To ensure \(\gamma_k\) is monotonically non-decreasing with evidence strength, we parameterize it using cumulative non-negative increments: \(\delta_i=\operatorname{softplus}\left(\tilde{\delta}_i\right) \geq 0, \quad i=1,2,3, \quad z_k=z_0+\sum_{i=1}^k \delta_i, \quad \gamma_k=\sigma\left(z_k\right)\) where \(z_0 \in \mathbb{R}\) and \(\tilde{\delta}_i \in \mathbb{R}\) are learnable parameters, \(\sigma(\cdot)\) is the sigmoid function, and softplus enforces \(\delta_i \geq 0\). This guarantees \(\gamma_0 \leq \gamma_1 \leq \gamma_2 \leq \gamma_3\) while keeping the mapping differentiable and adding only four scalar parameters (shared across facets in our implementation; a per-facet variant is straightforward).

8.0.0.5 Personalizer fine-tuning.

We use Qwen/Qwen2.5-7B-Instruct [38], [40] as the base model. Our soft-prompt personalizer is a two-layer MLP that maps each user’s facet representation to a sequence of virtual tokens. We first construct a user vector using a single-layer reliability-gated graph encoder (hidden size 512, ReLU, dropout 0.1). The projector uses a two-layer MLP: Linear(d_in -> 512) + Tanh + Linear(512 -> L*H), where \(d_{\mathrm{in}}\) is the user-vector dimension, \(L{=}20\) is the soft-prompt length, and \(H\) is the LLM hidden size (Qwen2.5-7B). The output is reshaped to \(L\times H\) and prepended to the token embeddings.

During training, we prepend soft_prompt to the token embeddings, extend the attention mask with ones for the virtual tokens, and set the corresponding labels to \(-100\) so that the loss is computed only over real tokens. We fine-tune the base model with LoRA [39] (rank 16, \(\alpha{=}32\), dropout 0.05), while optimizing the soft-prompt personalizer and graph encoder end-to-end. At inference time, we generate the soft prompt once per user and cache it for reuse.

We train for 10 epochs with batch size 1 and gradient accumulation of 4 (effective batch size 4), using AdamW [69] with learning rate \(2\times10^{-5}\), weight decay 0.01, and betas \((0.9, 0.98)\). We use a cosine learning-rate schedule with warmup ratio 0.06 and clip gradients to a maximum norm of 1.0. At inference, prompts include four retrieved reviews and up to three neighbors selected by the highest combined similarity. To fit within the model’s context window, we cap the input at 8192 tokens and apply per-component limits: 1024 tokens per retrieved review, 1024 tokens for the user’s historical reviews, and 512 tokens per neighbor facet summary.

9 Computational Cost Analysis↩︎

Most of the computation in our personalization pipeline can be performed offline and cached. Facet summarization, embedding extraction, and graph construction are per-user (or per-refresh) preprocessing steps, and the graph message passing can likewise be run ahead of time to produce a fixed user representation. We then precompute the user’s soft prompt (virtual tokens) once and store it. As a result, online inference only needs to retrieve the cached soft prompt and prepend it to the decoding context, without running any graph/message-passing or embedding-related computation on the critical path; consequently, the incremental runtime overhead during generation is negligible in practical deployments.

References↩︎