Architectures / Recommendation

💡 LightGCN

He et al. 2020 — user/item embeddings propagated through 3 light graph-conv layers, layer combination via mean (no transforms, no nonlinearities)

Layers

Parameters

70.42M

Input

Output

Verifier

Clean

Every number on this page is computed from the graph by the same functions the app runs, not written by hand.

Open LightGCN on the canvas Free, no account needed

When to pick it

Pick for collaborative filtering with implicit feedback (clicks, plays). Strips graph-conv to its essentials — often beats heavier GCN variants on rec benchmarks.

Structure

14 layers. Output shapes are propagated from the input shape, batch dimension excluded.

	Layer	Type	Parameters	Output shape
1	User ID	Input	shape=[1]	1
2	E_user(0)	Embedding	vocabSize=100000	1 × 64
3	GraphConv(1)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
4	GraphConv(2)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
5	GraphConv(3)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
6	Layer Combine (mean)	Mean		64
7	Item ID	Input	shape=[1]	1
8	E_item(0)	Embedding	vocabSize=1000000	1 × 64
9	GraphConv(1)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
10	GraphConv(2)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
11	GraphConv(3)	GraphConv	outFeatures=64, inFeatures=64	1 × 64
12	Layer Combine (mean)	Mean		64
13	Dot Score	MatMul		64
14	Score	Output		64

What the verifier says

The same 41 structural checks that run on every edit in the app, on this graph.

info11 layers with no BatchNorm, LayerNorm, or GroupNorm. Without normalization, activations can explode or vanish across layers, causing slow or unstable training. Fix: Add BatchNorm after Conv2d (CV tasks), LayerNorm after attention/FFN (NLP/LLM), or GroupNorm for small batch sizes.
deep-no-norm

The PyTorch it exports

Generated from the graph above. First 46 lines; the app exports the whole file, plus the training loop, the data contract and a deploy bundle.

# Architecture designed with Neurarch: https://neurarch.com
# PyTorch: compatible with Python 3.8+ and torch>=1.12
# Colab: pip install torch torchvision  (usually pre-installed)
#
# WARNING: 3 layer(s) below are not yet supported by the PyTorch
# exporter and pass their input through UNCHANGED in forward():
#   - Layer Combine (mean) (mean)
#   - Layer Combine (mean) (mean)
#   - Dot Score (matmul)

import torch
import torch.nn as nn
import torch.nn.functional as F
from typing import Tuple

class LightGCN(nn.Module):
    def __init__(self):
        super().__init__()

        self.embedding_1 = nn.Embedding(100000, 64)
        self.embedding_2 = nn.Embedding(1000000, 64)

    def forward(self, src, tgt=None):
        # User ID shape: [1]
        # Item ID shape: [1]
        embedding_ser_e0 = self.embedding_1(src)
        graph_conv_er_gc1 = self.graphConv_1(embedding_ser_e0, edge_index)  # pass edge_index from graph data
        graph_conv_er_gc2 = self.graphConv_2(graph_conv_er_gc1, edge_index)  # pass edge_index from graph data
        graph_conv_er_gc3 = self.graphConv_3(graph_conv_er_gc2, edge_index)  # pass edge_index from graph data
        # TODO: layer 'Layer Combine (mean)' (mean) is not yet supported by the exporter; passing through unchanged
        embedding_tem_e0 = self.embedding_2(tgt)
        graph_conv_em_gc1 = self.graphConv_4(embedding_tem_e0, edge_index)  # pass edge_index from graph data
        graph_conv_em_gc2 = self.graphConv_5(graph_conv_em_gc1, edge_index)  # pass edge_index from graph data
        graph_conv_em_gc3 = self.graphConv_6(graph_conv_em_gc2, edge_index)  # pass edge_index from graph data
        # TODO: layer 'Layer Combine (mean)' (mean) is not yet supported by the exporter; passing through unchanged
        # TODO: layer 'Dot Score' (matmul) is not yet supported by the exporter; passing through unchanged
        # Output
        return embedding_ser_e0


if __name__ == '__main__':
    model = LightGCN()
    model.eval()

    src = torch.randint(0, 1, (1))  # (batch, src_seq_len)
    tgt = torch.randint(0, 1, (1))  # (batch, tgt_seq_len)

For agents

This architecture is machine-readable end to end. An agent can list the set, fetch this graph, edit it, and have the edit verified before any GPU time is spent.

Markdown twin Index JSON This graph as JSON MCP server POST /api/v1/check

Also in Recommendation

🗼 Two-Tower

User+Item dual encoder for retrieval — embeddings → MLP per side → dot product score

Meta's Deep Learning Recommendation Model — bottom MLP for dense, embedding for sparse, feature interaction, top MLP

14 layers · 32.35M

🤝 Neural Collaborative Filtering

He et al

16 layers · 105.61M