DGCNN Dynamic Graph on Points

Points alone miss edges; connect each point to its neighbors and convolve the edges. DGCNN rebuilds that graph fresh in every layer.

Neighbor graphs rebuild in feature space while EdgeConv reads each edge

Why Does This Exist?

PointNet reads points in isolation, so sharp blades and thin chair legs blur together. DGCNN exists to add edges: for each point it finds $k$ nearest neighbors and convolves the difference vectors, capturing local shape explicitly. Recomputing neighbors in feature space lets distant but similar parts link up in deeper layers.

Attention on points is Point Transformer; the kernel-point alternative is KPConv.

Think of It Like This

Friend groups that reform by interest

Seat students by dorm first, then re-seat by hobby each term: artists find artists even across dorms. Early groups are spatial; later groups are semantic.

Coordinates seat the first graph; features re-seat deeper ones. The analogy stops at cost: reseating students is free while $k$ NN per layer costs real time on large clouds.

How It Actually Works

EdgeConv computes $x_i' = \max_{j \in \mathcal{N}(i)} h(x_i, x_j - x_i)$ with shared MLP $h$ over the center plus the edge difference. The first layer builds $\mathcal{N}$ by Euclidean $k$ NN with $k = 20$ ; deeper layers rebuild by feature-space $k$ NN, so semantically close points connect regardless of distance. Stacks of four EdgeConv blocks with shortcuts feed global max and average pooling into the classifier.

Worked numbers

Point $(0,0,0)$ with neighbors $(0.1,0,0)$ and $(0,0.1,0)$ gives edge vectors $(0.1,0,0)$ and $(0,0.1,0)$ . With $h(a,b) = |b|$ summed, outputs are $0.1$ and $0.1$ , max $0.1$ . On $1024$ -point ModelNet40 the reference rises from $91$ percent static-graph to about $93$ percent dynamic.

Code

1def edgeconv_center(edges: list[float]) -> float:2    return max(edges)  # symmetric over neighborhood3
4
5print(edgeconv_center([0.1, 0.1, 0.05]))  # -> 0.1

Watch Out For

Setting k blindly on sparse far clouds

Far cars hold $50$ points where near ones hold $800$ , so $k = 20$ spans whole objects far away but tiny patches nearby. The symptom is range-dependent features. Scale $k$ or radius with range, or sample fixed neighborhoods instead.

The Quick Version

DGCNN connects each point to $k = 20$ neighbors and convolves edges.
EdgeConv reads center plus difference, then max-pools the neighborhood.
Graphs rebuild per layer in feature space, not just XYZ.
Dynamic grouping lifts ModelNet40 near $93$ percent.
The operator suits sharp local shape that global pooling misses.
Sparse far clouds need range-aware neighborhoods.