Can cyclic aggregation between users and items enable fully inductive recommendation?
This explores whether passing signal back and forth between users and items — letting each refine the other in a loop — could build a recommender that handles brand-new users and items without retraining (fully inductive), and the corpus circles this goal from several angles even though it has no paper on that exact cyclic mechanism.
This question is really two questions stacked: (1) does bidirectional user↔item message-passing help, and (2) is that enough to reach *fully inductive* recommendation — predicting for users and items the model never saw during training. The corpus doesn't contain a paper on the specific 'cyclic aggregation' architecture, but it has a lot to say about both halves, and the lateral picture is more interesting than a single answer.
The back-and-forth aggregation idea shows up most directly in graph approaches. KGAT folds user-item interactions and item attributes into one 'Collaborative Knowledge Graph' and propagates attention-weighted signal across it, so a user's representation is shaped by items and an item's by users and its neighbors — exactly the alternating refinement the question describes — and crucially it captures *high-order* connections that flat supervised models miss Can graphs unify collaborative filtering and side information?. GHRS pushes the same graph intuition straight at the inductive goal: by fusing rating history with side information through graph features and autoencoders, it can score new users *and* new items, the classic cold-start case, by discovering non-linear structure that linear hybrids can't Can autoencoders solve the cold-start problem in recommendations?. So the corpus suggests cyclic/graph aggregation genuinely helps — but notice both wins lean on *side information*, not interaction loops alone.
That's the catch the rest of the corpus keeps surfacing: pure ID-based aggregation hits a wall the moment a truly new entity arrives, because a never-seen ID has no embedding to aggregate. Monolith's work shows why fixed embedding tables degrade as new IDs stream in, with hash collisions piling up on exactly the high-frequency users and items you most need right Why do hash collisions hurt recommendation models so much?. The strongest inductive results in the corpus get there by *escaping the ID* rather than by cleverer aggregation: VQ-Rec maps item text to discrete codes so lookup tables adapt to new domains without retraining Can discretizing text embeddings improve recommendation transfer?, TransRec blends ID, title, and attributes so generation stays grounded even for unfamiliar items Can item identifiers balance uniqueness and semantic meaning?, and P5 recasts everything as text to get zero-shot transfer to new items and domains Can one text encoder unify all recommendation tasks?.
There's a wilder answer hiding in the corpus too. Rec-R1 trains an LLM through closed-loop recommendation feedback and ends up recommending effectively *without ever seeing the catalog* — it learns to query the system the way a person searches a store without memorizing inventory Can LLMs recommend products without ever seeing the catalog?, using recommendation metrics like NDCG directly as RL rewards Can recommendation metrics train language models directly?. That's a different route to 'inductive': not aggregating over a known graph at all, but learning a generalizable query behavior. It reframes your question — maybe 'fully inductive' is less about a perfect user↔item loop and more about whether the model's knowledge lives in transferable text/codes/behavior rather than in fixed per-entity vectors.
So the honest synthesis: cyclic user↔item aggregation (KGAT, GHRS) is a strong *contributor* to inductive recommendation and clearly beats flat methods, but the corpus suggests it isn't *sufficient* on its own — the entities that break aggregation are precisely the never-seen ones, and the systems that actually achieve full induction do it by anchoring representations in content, codes, or learned behavior that survive a cold start. The loop helps you generalize over structure you've seen; it's the text-and-code decoupling and feedback-trained behavior that let you generalize past it.
Sources 8 notes
KGAT merges user-item interaction graphs with item knowledge graphs into a Collaborative Knowledge Graph, using attention-based propagation to capture both user-similarity and attribute-similarity signals simultaneously—including high-order connections that standard supervised learning methods miss.
GHRS uses graph features and deep autoencoders to integrate rating history with side information, enabling predictions for new users and items by discovering non-linear relationships that linear hybrid methods miss.
Monolith's empirical work shows that real recommendation systems have power-law distributed frequencies, causing collisions to accumulate precisely on the entities models need most accurate. Fixed-size hashed tables worsen this over time as new IDs arrive.
VQ-Rec uses product quantization to map item text to discrete codes that index learned embeddings, breaking the tight coupling between text and recommendations. This decoupling prevents text-similarity bias and allows lookup tables to adapt to new domains without retraining the text encoder.
TransRec shows that combining numeric IDs, titles, and attributes into structured identifiers solves three problems simultaneously: distinctiveness from IDs, semantics from text, and generation grounding from structural constraints. Neither pure IDs nor pure text alone achieves all three.
P5 converts user-item interactions and metadata into natural language and trains a single encoder-decoder across five recommendation task families, matching task-specific models while achieving zero-shot transfer to new items and domains. Unification trades efficiency for composability.
Rec-R1 experiments show that LLMs trained via RL with recommender metrics as rewards can generate effective product search queries without catalog access. The model learns query refinement indirectly through system feedback, paralleling how humans search without knowing platform inventory.
Rec-R1 demonstrates that LLMs can be trained directly on rule-based recommendation metrics like NDCG and Recall as RL reward signals, eliminating the need for SFT distillation from proprietary models while remaining model-agnostic across different retriever architectures.