Graph recommenders such as LightGCN score a user–item pair by averaging embeddings over the user–item interaction graph and then taking an inner product. This averaging is called linear graph convolution: neighborhood averaging with no nonlinearities and no per-layer weights. These models are known to push recommendations toward already-popular items. The leading explanation is about training dynamics. Under stochastic gradient descent, a popular item's influence on the gradient grows roughly as its degree to the power 3/2, so popular items drag everyone's embeddings toward themselves. Every fix built on this explanation so far either patches the embeddings after training or adds a regularizer that is still optimized by noisy minibatch gradient steps. We propose to remove the optimizer from the story. We rewrite linear graph collaborative filtering so that every parameter block is a weighted least-squares problem, solve it by alternating exact updates as in classic Alternating Least Squares (ALS), and give popularity its own explicitly solved block.
This buys two things. The first is a method: a recommender whose popularity correction is learned in closed form during training, with no post-hoc clustering, projection, or propensity estimates. The second, which we think matters more, is a controlled experiment. If the same objective solved exactly by ALS and solved by Adam yields the same tail-item behavior, then popularity amplification is a property of the objective and the propagation, not of gradient dominance. That would redirect where debiasing effort should go. If the two differ, the gradient-dominance account is confirmed at the level of converged solutions, which current evidence does not show.
Core Claim
Popularity bias in linear graph collaborative filtering can be handled inside training, exactly, once two changes are made. The first change unties the embedding table used for propagation from the table used for scoring. This turns the model's joint objective, which is quadratic in the shared table and therefore not ALS-friendly, into a sequence of convex weighted least-squares blocks. The second change adds a per-item popularity offset and a degree-dependent ridge penalty as further blocks. Their closed-form solutions show directly how much of each item's score is explained by degree. At inference the offset is down-weighted. The degree exponent of the ridge is chosen analytically so that tail-item embedding norms stop growing linearly with degree.
Where the Directions Meet and What Is Missing
Linear graph convolution supplies the model. Simplifying Graph Convolutional Networks showed that dropping nonlinearities turns graph learning into a convex problem over precomputed propagated features. LightGCN carried this idea to recommendation, where the "features" are the learned ID embeddings themselves. That is exactly why the convexity of the simplified graph convolution model is lost: the score $(\tilde A^K E)_u^\top(\tilde A^K E)_i$ is quadratic in the single table $E$. How Does Message Passing Improve Collaborative Filtering? constrains our design. It shows that LightGCN with gradients detached from message passing performs on par with full LightGCN, while removing neighbors from the forward pass costs about 29.7% NDCG@20 on Gowalla. Propagation matters at scoring time, not as an optimization aid. We therefore keep propagation in the score but are free to change how its parameters are tied.
Alternating optimization supplies the solver. Weighted ALS updates each user or item by solving a small linear system. Learning-Efficient Yet Generalizable Collaborative Filtering for Item Recommendation derives the RG² loss, a second-order expansion of softmax that is consistent with DCG and still admits closed-form weighted ALS updates. That paper reports MRR@10 of 0.4723 on MovieLens against 0.4487 for softmax. We reuse its weights and targets. Unlike that work, we add graph propagation and a popularity block. RG² is purely flat matrix factorization and does not model popularity.
The popularity literature motivates the gap and supplies our main competitors. How Graph Convolutions Amplify Popularity Bias for Recommendation? proves the degree-to-the-3/2 gradient dominance. Its fix, DAP, subtracts cluster-estimated amplification at inference. Post-hoc Popularity Bias Correction in GNN-based Collaborative Filtering (PPD) similarly projects out a popularity direction from frozen embeddings. Mitigating the Popularity Bias of Graph Collaborative Filtering: A Dimensional Collapse Perspective ties the bias to the embedding matrix losing rank and adds a LogDet barrier trained with BPR. Graph-Structured Driven Dual Adaptation uses degree-Gini-weighted contrastive alignment. All four accept stochastic training as given. Our proposal changes the training itself, and it tests whether their shared premise about the optimizer even holds. Among the causal methods, MACR is closest in spirit to our popularity block, since it subtracts a learned direct popularity effect at inference. MACR learns that effect by gradient descent in a separate branch. We solve it exactly, jointly with propagation-aware embeddings.
Research Program
The model scores a pair as
$$\hat r_{ui} = \Big(p_u + \sum_{j} s_{uj}\, y_j\Big)^{\top}\Big(q_i + \sum_{v} s_{iv}\, x_v\Big) + b_i .$$
Here $p_u, q_i$ are the user's and item's own embeddings. $y_j$ and $x_v$ are separate "context" embeddings that an item or user contributes to its neighbors. The weights $s_{uj}$ and $s_{iv}$ come from the symmetrically normalized interaction graph: for one hop they are $d_u^{-1/2}d_j^{-1/2}$, with $d$ the node degree, and for $K$ hops they are entries of an odd-power polynomial of the normalized adjacency. $b_i$ is a scalar popularity offset. Tying $y=q$ and $x=p$ recovers a LightGCN-style score. Untying them is what makes each block linear in its own parameters once the others are fixed.
The training objective uses the RG² weights $c_{ui}$ and targets $r_{ui}$, and a ridge penalty on items that scales with degree:
$$\min \sum_{u,i} c_{ui}\big(r_{ui}-\hat r_{ui}\big)^2 + \lambda_0\sum_i d_i^{\gamma}\lVert q_i\rVert^2 + \lambda\big(\lVert P\rVert^2+\lVert X\rVert^2+\lVert Y\rVert^2\big) + \mu\lVert b\rVert^2 .$$
The alternation cycles over five blocks. User embeddings $P$ and item embeddings $Q$ separate into independent small ridge regressions per row, computed with the usual full-data Gram-matrix trick, so each costs roughly the cost of solving a $d\times d$ system per row. Offsets $b$ have a per-item closed form. The context tables $Y$ and $X$ couple rows through the sparse graph, so we solve them with preconditioned conjugate gradient, using only sparse matrix multiplications. Every block is convex, so the objective decreases monotonically.
The analysis part makes popularity readable. For a tail item, the item's Gram matrix is dominated by the shared full-data term plus the ridge, while the right-hand side sums over its $d_i$ interacting users. Its norm therefore grows about linearly in $d_i$ when $\gamma=0$. We will derive the $\gamma$ that flattens this growth and check the prediction against measured norm–degree curves.
At inference, items are ranked by $\hat r_{ui}-(1-\eta)b_i$. With $\eta=0$ the learned popularity offset is removed entirely; $\eta=1$ keeps it. Because $b_i$ is solved jointly with the embeddings, the embeddings are free to explain taste rather than degree. We expect this to work better than subtracting a direction afterwards, but this is a hypothesis we test, not a premise.
Baselines
The naive reference points are plain weighted ALS on flat matrix factorization with RG² weights (no graph, no popularity block) and LightGCN trained with BPR. Mitigating the Popularity Bias of Graph Collaborative Filtering reports LightGCN at Recall@20 = 0.0639 on Yelp2018.
The strongest existing method on combined overall and tail accuracy is GCF$_{logdet}$. The same paper reports Recall@20 = 0.0725 on Yelp2018 and a 1.51× larger relative gain on unpopular items. Its LogDet barrier directly targets the rank loss that closed-form ridge solutions might not fix. Beating it means matching or exceeding its Yelp2018 Recall@20 and tail recall when we rerun it ourselves, while training in less wall-clock time.
The post-hoc competitors DAP and PPD are run on the same trained LightGCN checkpoint with their projection hyperparameters tuned. The file gives no absolute numbers for these methods, only relative claims: tail gains above 50% on Yelp2018 for DAP, and over 500% NDCG@20 on KuaiRec for PPD.
The test-time aggregation baseline uses the snap-research/Test-time-Aggregation-for-CF codebase. That codebase reports DirectAU+TAG-CF at Recall@20 = 0.0633 on Yelp2018 and 0.1072 on Gowalla. We also include a combination nobody has reported: RG²-trained weighted ALS with TAG-CF+ aggregation applied at test time only.
Fairness rules apply to all methods. Every method uses the same splits from the TAG-CF codebase, the same embedding dimension, and the same grid budget of 30 configurations tuned on validation NDCG@20. Wall-clock time is reported on the same hardware. Numbers quoted from papers serve only as sanity checks against our reruns, because their protocols may differ.
Two ablations isolate the key ingredients. The first optimizes our exact objective with Adam instead of alternating solves, at matched validation loss; this separates optimizer effects from objective effects. The second removes, one at a time, the popularity block, the degree ridge ($\gamma=0$), and training-time propagation.
Why not just…?
Why not just train LightGCN normally and apply DAP or PPD afterwards? These methods are cheap and report large tail gains, so they are serious competitors. Their known weakness is that they move already-collapsed embeddings along an estimated axis. That cannot restore rank lost during training, which is the effect documented in the dimensional-collapse paper. The weakness is plausible, not proven to matter. We will measure effective rank and tail recall for DAP-on-LightGCN against our model. If post-hoc projection matches us on both, the in-training argument fails and we will say so.
Why not just run RG² with ALS on flat factorization and add test-time aggregation, with no new graph objective? This is the real threat. TAG-CF's own evidence says training-time propagation is nearly useless, and RG² already supplies closed-form ranking-consistent training. The combination is new and may match us on overall accuracy. Our claimed advantage is specifically on popularity: test-time aggregation by itself makes no correction for popularity, and nothing in it constrains how item norms scale with degree. The decisive comparison runs this baseline both with and without our popularity block and degree ridge. If "flat RG²-ALS + popularity block + TAG-CF" equals our full model, then the untied graph objective is unnecessary. The contribution would then shrink to the closed-form popularity block, and we would report it that way.
Why not just normalize embeddings to the unit sphere, or reweight by inverse propensity? Adap-τ removes norm growth but is temperature-sensitive and does not address the collapse of embeddings in direction. Inverse propensity scoring is outperformed by over 15% in Recall and NDCG on MovieLens-10M by causal disentanglement in DICE, and it suffers high variance on rare items. We include unit-sphere ALS (row normalization after each solve) as a cheap ablation, which tests whether norm control alone accounts for our gains.
Proposed Experiments
The standard accuracy track covers Yelp2018, Gowalla, Amazon-Book, and MovieLens-1M. We report Recall@20 and NDCG@20 overall, tail recall (TR@20) on the bottom 80% of items as defined by DAP, effective rank of the final embeddings, and wall-clock time to convergence. The unbiased track uses KuaiRec, Coat, and Yahoo! R3, whose randomized test exposures separate genuine preference from exposure. We report Recall@20 and NDCG@20 against MACR, DAP, and PPD.
The decisive check is the optimizer ablation on Yelp2018 and Gowalla. We plot item embedding norm against degree and TR@20 against propagation depth $K$ for ALS-solved and Adam-solved versions of the identical objective. If the curves coincide, popularity amplification lives in the objective, and the gradient-dominance explanation does not describe converged solutions. If the Adam curves show sharper tail decay as $K$ grows, the optimizer matters, and closed-form training is itself a debiasing tool.
The second check is the $\eta$ sweep. We trace overall NDCG@20 against TR@20 for our model, GCF$_{logdet}$, and the RG²-ALS-plus-TAG-CF baseline. Our approach succeeds if its accuracy–tail frontier dominates both. The third check verifies that the analytically predicted $\gamma$ lands within the validation-optimal range, which would confirm that the closed form explains the bias rather than merely fitting it.
References
- Simplifying Graph Convolutional Networks
- LightGCN: Simplifying and Powering Graph Convolution Network for Recommendation
- How Does Message Passing Improve Collaborative Filtering?
- Learning-Efficient Yet Generalizable Collaborative Filtering for Item Recommendation
- How graph convolutions amplify popularity bias for recommendation?
- Post-hoc Popularity Bias Correction in GNN-based Collaborative Filtering
- Mitigating the Popularity Bias of Graph Collaborative Filtering: A Dimensional Collapse Perspective
- Graph-Structured Driven Dual Adaptation for Mitigating Popularity Bias
- Model-Agnostic Counterfactual Reasoning for Eliminating Popularity Bias in Recommender System
- Adap-τ : Adaptively Modulating Embedding Magnitude for Recommendation
- Disentangling User Interest and Popularity Bias for Recommendation with Causal Embedding