💻 computer science

FedCGR: Federated Cross-Domain Generative Recommendation

FedCGR is a federated cross-domain generative recommendation framework that overcomes data privacy and sparsity constraints by representing items as discrete semantic IDs derived from public metadata, thereby enabling cross-domain alignment through a shared vocabulary while using reliability-aware interfaces and prototype-personalized aggregation to effectively integrate local collaborative signals and mitigate negative transfer.

Original authors: Zhuodong Liu, Hugen Lv, Xiangyu Li, Bohan Guo, Peiyu Hu

Published 2026-08-12

📖 6 min read🧠 Deep dive

CC BY 4.0

Original authors: Zhuodong Liu, Hugen Lv, Xiangyu Li, Bohan Guo, Peiyu Hu

Original paper licensed under CC BY 4.0 (http://creativecommons.org/licenses/by/4.0/). ✨ This is an AI-generated explanation of the paper below. It is not written or endorsed by the authors. For technical accuracy, refer to the original paper. Read full disclaimer

Imagine you are trying to build a super-smart recommendation engine, like the one that suggests your next favorite movie or song. Usually, these engines need to see everything you've ever clicked on to learn your taste. But in the real world, your data is scattered across different apps and companies, and privacy laws (plus common sense) mean no one can just swap your personal history with a stranger's. This creates a puzzle: How do you teach a system to understand that someone who likes "spicy food" might also like "spicy music," without ever actually seeing their private lists?

This is the challenge of Federated Learning (training models together without sharing raw data) and Cross-Domain Recommendation (using knowledge from one area to help another). The paper tackles a specific, tricky version of this: what if the "language" the computers use to describe items is different in every domain? It's like trying to translate a recipe from a French chef to a Japanese chef when they use completely different words for "salt" and "heat." The authors propose a new way to solve this by creating a shared, stable dictionary that everyone agrees on, while still letting each chef keep their secret family recipes private.

The Problem: The "Lost in Translation" Dilemma

In the world of recommendation systems, computers often try to learn by looking at patterns in user behavior. But when you split this learning across different companies (federated learning), things get messy. Usually, to connect two different worlds (like "Grocery" and "Sports"), the system needs to find common ground, like users who shop in both places. But in a privacy-focused setting, those overlapping users are rare or hidden.

Previous attempts to fix this often tried to force the computers to align their internal "thoughts" (embeddings). But the authors argue this is like trying to align two different maps by squinting at them until they look similar—it's fragile and often leads to confusion. If the "maps" are slightly different, the recommendations get garbled.

The Solution: A Shared "Secret Code"

The authors, Zhuodong Liu and his team, introduce FedCGR (Federated Cross-Domain Generative Recommendation). Their big idea is to stop trying to align the messy, private thoughts and instead agree on a shared, stable language first.

Imagine every product in the world (a toaster, a running shoe, a bag of coffee) is given a unique, short code made of letters, like a barcode. This code is generated based on the item's public description (its title, category, and features), not on who bought it. This is called a Semantic ID (SID).

The Magic: Because the code is based on public text, the "Toaster" in the Grocery store and the "Toaster" in the Kitchen store get the exact same code. This creates a universal dictionary that everyone agrees on, without anyone needing to share their private shopping lists.

How FedCGR Works: The "Trust but Verify" System

Now that everyone speaks the same code language, the team had to solve two new problems:

The "Static Dictionary" Problem: Since the dictionary (the codes) is fixed to stay consistent, the system can't learn new "nuances" from the dictionary itself. It needs a way to add local flavor.
The "Bad Translation" Problem: If you just mix everyone's training data together blindly (a standard method called FedAvg), the differences between domains (like "Sports" vs. "Beauty") can confuse the model, making it worse than if it learned alone. This is called negative transfer.

FedCGR solves these with two clever tricks:

1. The "Reliability-Aware" Injection
Think of the fixed SID code as the skeleton of the item. But a skeleton doesn't tell you if a user actually likes that item. To add the "flesh," each local computer (client) adds a small hint based on its own private data.

However, not all hints are good. If an item is very popular, the hint is strong. If it's a weird, rarely bought item, the hint might be noisy.
FedCGR uses a confidence gate. It asks, "Is this local hint trustworthy?" If the item is popular locally, the hint is let in. If it's obscure, the hint is muted. This ensures the system only uses local data when it's reliable, preventing "noise" from ruining the shared model.

2. The "Personalized Team" (Prototype Aggregation)
Instead of forcing all domains to agree on one single "average" model, FedCGR acts like a smart team leader.

It looks at the "personality" (a mathematical summary called a prototype) of each domain.
If the "Grocery" domain is very similar to the "Kitchen" domain, the system mixes their knowledge heavily.
If "Grocery" is very different from "Sports," the system keeps their knowledge separate and only shares the parts that are truly universal.
This is like a study group where students from similar majors (Biology and Chemistry) share notes deeply, while the student from Art History only shares general study tips, keeping their specific art knowledge private.

What They Found

The team tested FedCGR on six different scenarios using real Amazon data (mixing domains like Food, Kitchen, Beauty, Sports, and Grocery).

It Works Better: FedCGR consistently beat other federated methods. In the most chaotic, mixed-up scenarios (where domains were very different), it improved recommendation accuracy by nearly 20% compared to standard methods.
It Handles Cold Starts: For new users with very little history (the "cold start" problem), the shared SID language provided a solid foundation, helping the system make good guesses even without much data.
The Trade-off: The system does require a bit more communication between computers (about 18% more data sent per round) because it sends these personalized summaries. However, because it learns faster and avoids mistakes, it actually reaches the goal with less total communication overall.

The Takeaway

FedCGR shows that you don't need to sacrifice privacy to get smart recommendations. By agreeing on a stable, public "code" for items and then carefully mixing in local knowledge only when it's trustworthy, you can build a system that learns from everyone without anyone having to reveal their secrets. It turns a messy, privacy-heavy problem into a clean, collaborative game where everyone speaks the same language but keeps their own secrets safe.

Technical Summary: FedCGR

Problem Statement

Cross-domain recommendation (CDR) aims to transfer preference knowledge across related domains to mitigate data sparsity and cold-start issues. However, deploying CDR in a Federated Learning (FL) setting introduces a fundamental tension. Traditional CDR relies on "behavioral anchors"—such as overlapping users, co-occurrence graphs, or shared interaction signals—to align item spaces across domains. In a federated environment, these anchors are often sparse, unavailable, or privacy-sensitive because raw user interactions are held locally by different clients (e.g., platforms or business units) and cannot be centralized.

Existing federated CDR methods are predominantly discriminative, attempting to align private, continuous representation spaces across clients. This creates a coupling between privacy and alignment effectiveness: forcing clients to align private embeddings often leads to negative transfer under domain heterogeneity or fails due to the lack of shared behavioral signals. While Generative Recommendation using Semantic IDs (SIDs) offers a unified item language based on public metadata, directly federating SID-based generators introduces two new constraints:

The Semantic-Only Bottleneck: To maintain cross-client token consistency, the SID tokenizer must remain fixed. This prevents the global sharing of domain-specific collaborative filtering (CF) signals, as local CF embeddings trained independently are not coordinate-aligned.
Negative Transfer in Aggregation: Standard federated averaging (FedAvg) is inadequate for autoregressive SID generation under domain heterogeneity. Perturbations in early token distributions can cascade through the generation process, causing negative transfer when domains are behaviorally dissimilar.

Methodology: FedCGR

The authors propose FedCGR (Federated Cross-Domain Generative Recommendation), a framework designed to keep the "item language" stable while making adaptation explicit. The architecture consists of two coupled mechanisms:

1. Reliability-Aware Semantic Interface

This component addresses the semantic-only bottleneck by injecting local CF evidence into the stable SID representations without violating privacy.

Stable SID Vocabulary: A Residual Quantization VAE (RQ-VAE) tokenizer is pre-trained on public item-side metadata (titles, categories, descriptions) and frozen during federated training. This ensures that the same SID token refers to the same semantic region across all clients.
Local CF Extraction: Each client independently trains a lightweight sequential model (e.g., SASRec) on its private interactions to generate local CF item embeddings. These embeddings are never shared.
Residual Fusion: For each item in a user sequence, the input representation is constructed as the sum of the SID token embedding and a residual CF signal.
- Item-Level Reliability ( $\rho$ ): A confidence score based on local interaction frequency determines the trustworthiness of the CF embedding. High-frequency items receive higher weights; long-tail items are down-weighted to suppress noise.
- Client-Local Gate ( $g_i$ ): A learnable gate calibrates the overall contribution of CF evidence at the domain level.
- Adapter: A local behavior adapter maps the client-specific CF embedding space into the generator's hidden space.
Training-Only Regularization: A local dense prediction head is used during training to encourage the shared encoder to preserve reliable CF evidence via a confidence-weighted InfoNCE loss, but this head is discarded during inference.

2. Prototype-Personalized Federated Generator

This component addresses negative transfer by moving beyond uniform aggregation.

Shared-Private Expert Architecture: The generator employs a Mixture-of-Experts (MoE) block containing shared experts (participating in federation) and private experts (kept local). This allows the model to learn general patterns while retaining domain-specific capacities.
Domain Prototypes: Clients compute a compact domain prototype from the encoder memories of their local data. This prototype serves as a summary of the domain's behavioral distribution.
Similarity-Aware Aggregation: Instead of FedAvg, the server performs prototype-personalized aggregation. Shared parameters for a target domain are aggregated as a weighted sum of parameters from all clients, where weights are determined by the cosine similarity between the target domain's prototype and the source domain's prototype, adjusted by data volume. This ensures that knowledge is transferred primarily from behaviorally related domains.

Key Contributions

Formulation: The paper formulates federated CDR as generation over a stable semantic item language, where public metadata defines a shared vocabulary and raw interactions remain local.
Framework Design: FedCGR introduces a reliability-aware semantic interface that injects local CF evidence via confidence-gated residuals, solving the semantic-only bottleneck.
Personalized Aggregation: It proposes a prototype-personalized generator that uses domain prototypes to selectively aggregate shared parameters, mitigating negative transfer in heterogeneous federated settings.
Empirical Validation: Extensive experiments on six Amazon cross-domain scenarios demonstrate that FedCGR outperforms federated generative baselines and competes with strong sequential and federated discriminative CDR methods.

Experimental Results

The authors evaluated FedCGR on six scenarios involving five Amazon domains (Food, Kitchen, Grocery, Beauty, Sports) with varying levels of domain relatedness (high-affinity to low-affinity).

Performance vs. Federated Baselines: FedCGR consistently outperformed federated generative baselines (TIGER+FedAvg, TIGER+FedProx) and federated discriminative methods (FedDCSR, FedSASRec). In the most heterogeneous 4-domain scenario (GKBS), FedCGR improved N@10 by 19.4% over TIGER+FedProx and 22.4% over FedDCSR.
Performance vs. Non-Federated: FedCGR achieved competitive performance against non-federated discriminative baselines (SASRec, GRU4Rec), often surpassing them in sparse or high-heterogeneity scenarios, despite the privacy constraints.
Cold-Start Analysis: The stable SID vocabulary provided a strong foundation for cold-start users (few interactions), while the reliability-aware CF residual provided increasing benefits as user activity grew.
Efficiency: Although FedCGR has a slightly higher per-round communication cost (approx. 18% more parameters due to shared experts), it converges faster. The total communication budget required to reach a target accuracy was reduced by 34–45% compared to FedAvg baselines.

Significance and Claims

The paper claims that FedCGR successfully resolves the tension between federated privacy and cross-domain alignment by shifting the alignment mechanism from private behavioral data to a public, stable semantic vocabulary.

The authors highlight a specific "cross-over pattern" revealed by ablation studies:

In high-affinity scenarios (similar domains), the primary bottleneck is recovering domain-specific collaborative behavior; thus, the reliability-aware CF interface is the critical component.
In high-heterogeneity scenarios (dissimilar domains), the primary bottleneck is negative transfer; thus, prototype-personalized aggregation becomes the binding constraint.

The work demonstrates that federated generative recommendation requires not just a shared token space, but also mechanisms for reliability-aware behavior injection and similarity-aware parameter sharing to be effective. The code is publicly available, and the framework is presented as a robust solution for cross-silo federated recommendation where data silos are organizationally separated.