LightGCN

On this page 7

LightGCN (Light Graph Convolution Network) is a graph neural network for collaborative filtering that learns user and item embeddings by repeatedly averaging them over the user-item interaction graph, with no feature transformations and no nonlinear activations. In recommender systems, it became a widely used baseline after its 2020 introduction because it showed that a radically simplified graph convolution outperforms heavier designs on implicit-feedback recommendation.

The model treats every click, purchase or play as an edge between a user node and an item node. Information flows along those edges, so a user embedding absorbs signals from the items the user touched and, after several layers, from similar users and their items. Recommendations are produced by scoring user-item pairs with a simple inner product of the final embeddings.

How LightGCN propagates embeddings

LightGCN learns only one set of parameters: the initial ID embeddings of every user and every item, often with 64 dimensions. At each layer, a node’s new embedding is the normalized sum of its neighbors’ embeddings from the previous layer. The normalization factor for an edge between user u and item i is 1 divided by the square root of the product of their degrees, which prevents popular nodes from dominating the scale of the embeddings.

In matrix form, each layer multiplies the embedding table by the symmetrically normalized adjacency matrix of the bipartite graph. After K layers, typically K = 3, the model combines all layer outputs into one final embedding by a weighted sum, usually with equal weights of 1/(K+1). This layer combination captures both direct preferences (layer 0 and 1) and higher-order collaborative signals (layers 2 and 3) while reducing oversmoothing.

The table summarizes the main components and their role in the model.

ComponentWhat it doesTypical setting
Initial embeddingsOnly trainable parameters64 dimensions per user and item
Neighbor aggregationSums normalized neighbor embeddingsSymmetric degree normalization
Number of layersSets the reach of propagation2 to 4, most often 3
Layer combinationAverages embeddings from all layersEqual weights of 1/(K+1)
Scoring functionInner product of user and item vectorsDot product, no extra network
Components of the LightGCN model

What LightGCN removes from NGCF

LightGCN was derived by ablating Neural Graph Collaborative Filtering (NGCF), an earlier model that copied graph convolution design from node classification tasks. The authors observed that feature transformation matrices and nonlinear activations add little value when nodes carry only ID embeddings with no semantic features, and that they make training harder.

Removing both components reduced the parameter count and improved accuracy by roughly 16 percent relative on public benchmarks such as Gowalla, Yelp2018 and Amazon-Book, measured with Recall@20 and NDCG@20. The comparison below shows the design differences.

AspectMatrix factorizationNGCFLightGCN
Uses graph propagationNoYesYes
Weight matrices per layerNoneTwo per layerNone
Nonlinear activationNoneLeakyReLUNone
Final representationLayer 0 onlyConcatenation of layersWeighted sum of layers
Trainable parametersID embeddingsEmbeddings plus weightsID embeddings only
Relative accuracyBaselineBetter than baselineBest of the three
LightGCN compared with NGCF and matrix factorization

Training objective and hyperparameters

LightGCN is trained with Bayesian personalized ranking (BPR) loss, a pairwise objective for implicit feedback. For each observed interaction, the trainer samples an item the user has not interacted with, and the loss pushes the score of the positive item above the negative item. Negative sampling is therefore part of every training step, and L2 regularization applies only to the initial embeddings, because they are the sole parameters.

The following table lists the hyperparameters that usually matter most and their effect on results.

HyperparameterCommon rangeEffect when increased
Embedding size32 to 256More capacity, more memory
Number of layers1 to 4Wider reach, risk of oversmoothing
L2 regularization1e-5 to 1e-3Less overfitting, slower convergence
Learning rate1e-3 typical with AdamFaster but less stable training
Negatives per positive1 to severalStronger ranking signal, higher cost
Key LightGCN hyperparameters

Where LightGCN fits in a recommendation pipeline

In production, LightGCN mostly serves as a candidate generation model. Because scoring is an inner product, the final item embeddings can be indexed with approximate nearest neighbor search, and the system retrieves a few hundred candidates per user in milliseconds. A separate ranking model with richer context features, such as a CTR prediction network, then orders those candidates in a multi-stage ranking setup.

LightGCN competes with the two-tower model for this retrieval role. A two-tower model can use content and context features and handles new items easily, while LightGCN exploits high-order collaborative signals directly from the interaction graph and is often more accurate on dense interaction data with stable catalogs.

Limitations and common pitfalls

LightGCN is transductive: it learns one embedding per known ID, so it cannot score a new user or item without retraining or a separate fallback, which makes the cold start problem more severe than in feature-based models. Full-graph propagation also requires sparse matrix multiplication over all edges at every epoch, which becomes costly for graphs with billions of interactions unless sampling or precomputation is used.

SymptomLikely causeCommon remedy
Recommendations dominated by bestsellersPopularity bias amplified by propagationDegree-aware reweighting or debiasing losses
Accuracy falls with more layersOversmoothing of embeddingsKeep 2-3 layers, use layer combination
New items never appearTransductive ID embeddingsHybrid model with content features
Training too slow on large graphsFull-graph propagation each epochNeighbor sampling or mini-batch subgraphs
Offline gains not seen onlineEvaluation leakage or stale graphTime-based splits and frequent retraining
Typical LightGCN problems and remedies

Explained without jargon

LightGCN is a way to guess what people will like from who liked what. Picture a huge map with dots for people and dots for products. A line joins a person to every product they bought or watched.

The method lets each dot borrow a little of the character of its neighbors, then of its neighbors’ neighbors. After a few rounds, people with similar tastes end up with similar descriptions, even if they never bought the same thing. The key takeaway is that a very simple averaging process, repeated a few times, captures taste remarkably well.

A typical use case

A mid-sized online bookstore with 2 million customers and 300,000 titles wants better “you may also like” suggestions on its home page. The data team builds an interaction graph from 18 months of purchases and wishlist additions and trains LightGCN with 64-dimensional embeddings, three layers and BPR loss on a single GPU in a few hours.

Item embeddings are loaded into an approximate nearest neighbor index that returns 200 candidates per customer, and the existing ranking model reorders them using price, stock and recency. In an A/B test, the new candidate generator lifts click-through on recommendations by about 9 percent compared with the previous matrix factorization model. New releases, which LightGCN cannot see yet, are added through a separate content-based rule until the nightly retraining includes them.