When a new product, video, or article enters a catalog, no one has interacted with it, so a recommender must guess its audience from its content: its images, its text, its category. A strong recent recipe builds a fixed "item-item" graph that links each item to its most similar items by content. A new item then borrows the learned behavior of its content neighbors. This proposal starts from one observation. An item's content does not change over time, but whether its content neighbors are still in demand, and among which users, does change. A new winter coat whose closest content neighbors are last year's best-sellers inherits their audience, even if that audience has since moved on.
We propose to keep the cheap content graph frozen and let its edge weights drift. Each neighbor's influence on a new item is reweighted by how much that neighbor is currently being engaged with inside each user community. This "aliveness" is a time-discounted count that can be updated incrementally from new interactions within a bounded 2-hop neighborhood. It never requires relearning the graph or computing global graph statistics. The claim is that most of the accuracy lost to temporal drift on cold items comes from borrowing from stale neighbors, and that fixing which neighbors are borrowed from, and for which users, recovers it at a small fraction of the cost of relearning.
Core Claim and Positioning
Two papers motivate the claim. FREEDOM builds a k-nearest-neighbor item graph from raw multimodal features once and freezes it during training. It reports an average 19.07% gain in Recall@20 and NDCG@20 over LATTICE, which relearns the item graph every epoch, along with up to 6x less memory and 4x faster training. Its weakness for our setting is that the frozen graph and its degree-based edge pruning treat a five-year-old interaction like yesterday's. FREEDOM is also evaluated on 5-core random splits, which never stress true cold items under drift.
TDRO shows the other half of the picture. On chronologically split Amazon Clothing, Micro-video, and Kwai, the relationship between item features and user preference shifts over time. TDRO addresses this with a robust training objective over K-means feature clusters, upweighting groups whose importance is rising. TDRO changes the loss. It does not change which warm items a cold item draws on, and it ignores interaction-graph structure entirely.
Our proposal is different from both. Unlike FREEDOM, edge weights on the frozen graph are time-varying. Unlike TDRO, the adaptation happens through propagation on the graph, and it is conditioned on user communities, not on feature clusters.
Three further lines of work shape the design. The time-discounting form comes from NS-DPO, which weights each training pair by $\gamma^{T-t_i-1}$. It keeps reward accuracy above 60–70% where standard DPO falls to roughly 50–55% after preference flips. NS-DPO also flags the open problem that the best $\gamma$ depends on an unknown amount of drift, and we address that problem directly.
The bounded-neighborhood constraint comes from network science. Global centralities do not scale: exact betweenness did not finish within an hour on the roughly 19,000-node Ca-Astroph graph in HKEN. Expanding past 3–4 hops explodes combinatorially (Ali et al.). Semi-local walks in RMLRW and closed-form random walks in S-Walk get most of the benefit of global structure at near-linear cost.
The hub concern comes from Mecos, whose few-shot matcher for cold items degrades when embeddings crowd around dense hubs. We borrow HKEN's idea of attenuating influence that passes through highly clustered nodes as a guard against cold items collapsing onto popular anchors.
Mechanism
Let $s_{ca}$ be the frozen content similarity between cold item $c$ and warm anchor $a$, taken from the FREEDOM-style graph. User communities are fixed partitions $C$ of the user–user co-engagement graph, computed with Leiden once per epoch of the data. Leiden is a fast community-detection algorithm, and this step is a quasi-local operation. For each anchor and community we maintain a discounted engagement count:
$$\rho_{a,C}(t) = \sum_{(u,a,\tau):\, u \in C,\ \tau \le t} \gamma^{\,t-\tau}.$$
Here $(u,a,\tau)$ ranges over interactions of user $u$ with anchor $a$ at time $\tau$, and $\gamma \in (0,1]$ is the discount. This count updates in constant time per new interaction.
A cold item's representation for users in community $C$ is propagated with weights
$$w_{ca}^{C}(t) \propto s_{ca}\,\big(\epsilon + \rho_{a,C}(t)\big)^{\alpha}\,(1-\mathrm{CC}_a)^{\beta},$$
where $\epsilon$ is a small floor so that dormant anchors keep some weight, $\alpha$ controls how sharply aliveness reshapes the neighborhood, and $\mathrm{CC}_a$ is the anchor's local clustering coefficient in the item graph. Setting $\beta>0$ applies the HKEN-style hub penalty. Weights are normalized over the $k$ anchors.
Propagation runs for at most two hops on the item graph, on top of a LightGCN-style backbone trained on discounted user–item edges. This keeps the per-update cost at $O(k^2)$ per touched anchor. For comparison, LATTICE relearns the graph every epoch.
To handle the unknown amount of drift, we keep a small bank of discount values $\gamma \in \{0.9, 0.97, 0.99, 1\}$ per time step. These cost nothing extra to maintain, since each is just one more counter per anchor-community pair. At each period we select among them, or mix them, using performance on the most recent validation slice.
Research Program
The work has three parts.
The first is a diagnostic study. On chronological splits, we measure how much of FREEDOM's accuracy loss on cold items, relative to warm items, tracks the staleness of their content neighbors. Staleness is defined as the fraction of each neighbor's interactions that are older than one validation period. If cold-item error does not correlate with neighbor staleness, the premise is wrong and we stop.
The second is building the drifting-weight graph with incremental updates, and measuring wall-clock cost and memory against full retraining and against LATTICE.
The third is an analysis of when community conditioning matters. We stratify results by the community entropy of cold items' anchor sets, following community structure entropy. We also examine the Ca-Erdos-style failure mode that HKEN reports: graphs without clear community structure, where community-conditioned weights should add nothing over a single global aliveness signal.
Baselines
The naive reference is FREEDOM run as published, with a frozen content graph and undiscounted training. We retrain it on the same chronological 8:1:1 splits of Amazon Clothing, Micro-video, and Kwai that TDRO uses, and on chronological re-splits of Amazon Baby and Sports with the 5-core filter relaxed so that true cold items, with zero training interactions, appear in the test set. This is the floor any proposal must clear.
The strongest existing method for this exact question is TDRO, because it is the only work in the file designed for cold items under temporal feature shift with multimodal content. We run it with its released configuration, on the same content features, with the same backbone embedding size and the same hyperparameter search budget as our method: an equal number of trials over its group count and shift-factor weight. The file reports that TDRO beats CLCRec and GAR on cold-item Recall@20, but no reported result found on Lacuna for TDRO's absolute cold-item Recall@20 on Clothing, Micro-video, or Kwai. We will therefore report our own reproduction alongside the paper's protocol. Beating TDRO means a statistically significant cold-item Recall@20 and NDCG@20 gain over five seeds on at least two of the three chronological datasets. Because the two methods act on different parts of the model, one on the training loss and one on the propagation weights, we also run TDRO combined with drifting weights to test whether the gains add up.
The baseline most likely to erase our contribution is FREEDOM trained with NS-DPO-style discounting of user–item edges but with content-only item-item weights. It is discussed below. LATTICE is included as the "relearn the graph" upper reference on cost. All methods share the same frozen visual and text features and the same compute budget.
Ablations isolate the ingredients one at a time: community conditioning (a single global $\rho_a$ in place of $\rho_{a,C}$), the hub penalty ($\beta=0$), the discount bank (a single fixed $\gamma$), and a random community partition. The random partition is important. If it matches Leiden communities, the gain is not structural.
Why not just…?
Why not just apply time decay to user–item edges in FREEDOM and leave the item graph alone? This is the real threat. Warm items' embeddings would then reflect recent behavior, and cold items inherit those embeddings through the content graph. Our argument is that the cold item still averages over all $k$ content neighbors with content-only weights. A neighbor whose demand has died keeps its full weight, and only its embedding has changed. Whether that matters is an empirical question, and the decayed-FREEDOM baseline above settles it. If decayed-FREEDOM matches drifting weights to within seed noise, we will report that the item-graph reweighting is unnecessary.
Why not just add a recency-popularity boost to cold items' scores? A scalar boost changes how often a cold item is shown. It does not change to whom. Our weights change which user communities a cold item reaches. To separate the two, we evaluate on candidate sets matched for recent popularity, where a global prior cannot help, and we report per-community ranking quality. If gains vanish under popularity matching, the method is a popularity prior in disguise.
Why not just rebuild the item graph periodically, or relearn it as LATTICE does? Rebuilding from content returns the same graph, because content does not change. That is precisely why drift has to enter through weights. Relearning it from behavior, as LATTICE does, is what FREEDOM showed to be both slower and less accurate. We include LATTICE so the cost and accuracy comparison is measured directly in this setting, not assumed.
Why not just use TDRO's robust objective? TDRO reweights training groups. It cannot change a specific cold item's neighborhood at test time without retraining. The TDRO-plus-drifting-weights run tests whether the two are complementary or redundant.
Proposed Experiments and Decisive Checks
The primary metrics are cold-item Recall@20 and NDCG@20 per test period, plus the slope of degradation across successive periods. Drift-robust methods should degrade more slowly. Cost is measured as update wall-clock time per period and peak memory.
Three outcomes decide the proposal. The first is the staleness diagnostic: cold-item error must correlate with neighbor staleness. The second is beating discounted-FREEDOM under popularity-matched evaluation; this is the result the contribution stands or falls on. The third is that Leiden communities must beat random partitions. Two further checks are expected rather than decisive. On data with weak community structure, community conditioning should add nothing beyond global aliveness. And per-period update cost should stay within a small constant factor of the FREEDOM forward pass, while LATTICE relearning should stay orders of magnitude slower on Kwai.
References
- A Tale of Two Graphs: Freezing and Denoising Graph Structures for Multimodal Recommendation
- Mining Latent Structures for Multimedia Recommendation
- Temporally and Distributionally Robust Optimization for Cold-Start Recommendation
- Right Now, Wrong Then: Non-Stationary Direct Preference Optimization under Preference Drift
- Identifying influential nodes through hierarchical k-shell and extended neighborhood integration
- Comparison of large networks with sub-sampling strategies
- Reliable multiplex semi-local random walk based on influential nodes to improve link prediction in complex networks
- S-Walk: Accurate and Scalable Session-based Recommendation with Random Walks
- Cold-start Sequential Recommendation via Meta Learner
- Measurement of influential nodes in networks based on community structure information entropy