📚TheoryIntermediate

Message Passing on Meshes & Point Clouds

Key Points

•
Message passing treats meshes and point clouds as graphs where nodes exchange information with neighbors to learn useful features.
•
PointNet achieves permutation invariance by applying the same MLP to each point and using a symmetric global pooling operation like max or sum.
•
Meshes add explicit connectivity $\frac{f a ces}{e d g es}$ , while point clouds often build k-NN or radius graphs to define neighborhoods for message passing.
•
Permutation invariance means reordering the input points does not change the output, which is critical because sets have no inherent order.
•
Graph Neural Networks generalize convolutions by aggregating messages from neighbors using symmetric functions, enabling local-to-global reasoning.
•
Practical pipelines often combine PointNet-style global features with local message passing on k-NN graphs for fine geometry.
•
Complexity typically scales with the number of edges: one message passing layer is O(EF) in time and O(NF) in memory for feature dimension F.
•
Implementation details like symmetric aggregation, normalization, and robust neighborhood construction strongly affect stability and accuracy.

Prerequisites

→Linear Algebra (vectors, matrices) — Neural layers and features are linear transforms of vectors and matrices.
→Graph Basics (nodes, edges, adjacency) — Message passing operates on graphs induced by meshes or constructed on point clouds.
→Neural Networks & MLPs — Message and update functions are typically implemented as MLPs with activations.
→Big-O Notation — To reason about the cost of neighborhood construction and per-layer operations.
→3D Geometry & Distance Metrics — k-NN/radius graphs depend on Euclidean distances and coordinate handling.
→Probability & Initialization — Understanding random weight initialization and its effect on forward passes.
→Normalization Techniques — Stabilize training and prevent over-smoothing in deep stacks.
→C++ Vectors and Memory — Efficiently storing features, adjacency, and implementing layers in C++.

Detailed Explanation

Tap terms for definitions

01Overview

Message passing on meshes and point clouds is a geometric deep learning framework that lets neural networks operate on 3D data without relying on regular grids. A mesh can be viewed as a graph whose vertices are 3D points connected by edges (from faces), whereas a point cloud is a set of 3D points with no inherent connectivity. To learn from these structures, we endow them with a graph: either the mesh’s native edges or a constructed k-nearest-neighbor (k-NN) or radius graph for point clouds. A Message Passing Neural Network (MPNN) updates each node’s feature by aggregating information (messages) from its neighbors using symmetric functions like sum, mean, or max. PointNet is a seminal architecture for point clouds that processes each point independently with a shared MLP, then applies a global symmetric pooling (e.g., max) to produce a permutation-invariant global descriptor. While PointNet captures global shape well and is robust to permutations, it initially lacked explicit local geometry modeling; later variants (PointNet++, DGCNN/EdgeConv) added local neighborhoods to improve detail. In practice, modern systems blend these ideas: use local message passing for fine structure and symmetric pooling for global summarization. The core challenges include ensuring permutation invariance, building reliable neighborhoods, maintaining computational efficiency, and preventing issues such as over-smoothing in deep graph stacks.

02Intuition & Analogies

Imagine a group chat where each person (node) talks to their immediate friends (neighbors). Each round, you read your friends’ messages, summarize them (e.g., take the average or pick the most urgent), and update your opinion. After a few rounds, your view reflects not only you but also your wider social circle. This is message passing. The summarization must be order-agnostic: it shouldn’t matter in what order you read messages—whether you read Alice or Bob first, you end up with the same summary. That’s why we use symmetric aggregations like sum/mean/max. For point clouds, think of a bag of marbles (points) spilled on a table. There’s no left-to-right order; you can reorder the marbles and the pile is still the same pile. PointNet respects this by treating each marble with the same function (shared MLP) and then using a symmetric pooling to mix them into one shape descriptor. For meshes, the marbles are connected with rubber bands (edges). Message passing uses these connections to spread information—like heat diffusion—so a vertex learns not only from itself but from its neighbors and neighbors-of-neighbors across layers. If you only use PointNet’s global pooling, you get the big picture (overall shape) but may miss local dents and bumps. If you only use local message passing, you might capture details but miss the global context. The best of both worlds is to let local chats happen and then summarize globally with a symmetric pooling.

03Formal Definition

Let G = (V, E) be a graph with node features

h_{v}^{(0)}

\in

R^{F}

and optional edge features

e_{uv}

. A general message passing layer updates each node v by computing messages from its neighbors N(v), aggregating them with a permutation-invariant operator

□

, and applying an update function:

h_{v}^{(k + 1)}

\phi\Big

(

h_{v}^{(k)}

□_{u \in N (v)}

\psi\big

(

h_{v}^{(k)}

h_{u}^{(k)}

e_{uv}\big

)

\Big

). Here,

ψ

and

ϕ

are learnable functions, often MLPs;

□

is a symmetric function such as sum, mean, or max. For point clouds X = \{

x_{i}

\in

R^{d}

\}_{

i=1}^{n}

, a set function f is permutation invariant if for any permutation

π

, f(\{

x_{i}

\}) = f(\{

x_{π (i)}

\}). PointNet approximates continuous set functions using f(X)

\approx

\gamma\Big

(

POOL_{i = 1}^{n}

x_{i}

)

\Big

), where h and

γ

are MLPs and POOL is a symmetric operator

\frac{ma x}{s u m}

. Meshes come with explicit edges from faces; point clouds typically induce graphs via k-NN or radius queries in

R^{d}

. Graph convolution variants (e.g., GCN) apply normalized adjacency to features, while EdgeConv/DGCNN forms messages on (

x_{j}

x_{i}

) to encode local geometry. Stacking K layers expands a node’s receptive field to nodes within K hops, enabling hierarchical feature learning over the structure.

04When to Use

Global shape classification of point clouds: Use PointNet-style shared MLP with global symmetric pooling for strong permutation invariance and simplicity. - Local geometric understanding (segmentation, keypoint detection, normals): Use message passing on k-NN or radius graphs to leverage neighborhood structure. - Mesh processing tasks (shape analysis, smoothing, attribute prediction): Use mesh edges as the graph to respect surface topology and geodesic neighborhoods. - Robotics and autonomous driving (LiDAR): Build sparse k-NN graphs and apply efficient message passing to capture both local obstacles and global scene context. - When inputs are unordered sets: Prefer architectures with symmetric aggregations (PointNet or GraphSAGE with symmetric aggregators). - When long-range context matters: Stack multiple message passing layers or combine with global pooling/attention. - When efficiency is critical: Control k in k-NN, use sparsity-aware data structures, and prefer O(EF) message passing over dense O(N^2) interactions.

⚠️Common Mistakes

Ignoring permutation invariance: Applying order-sensitive operations (e.g., concatenating points in a fixed order) breaks set semantics; always use symmetric aggregations. - Building poor neighborhoods: Using k-NN with too small k fragments the graph; too large k increases cost and may connect unrelated regions. Validate with radius graphs or hybrid schemes. - Feature leakage vs. over-smoothing: Stacking many layers without residuals or normalization can make node features indistinguishable. Use residual connections, normalization, and careful depth. - Mixing coordinate frames: Not normalizing or centering point clouds can hurt generalization; apply consistent scaling/centering or use relative features (x_j - x_i). - Ignoring edge cases: Isolated nodes, duplicate points, or degenerate meshes can cause empty neighborhoods or numerical issues; add fallbacks (self-loops, default messages). - Costly all-pairs construction: Naive O(N^2) k-NN kills performance at scale; prefer spatial indexing (kd-trees) or approximate neighbors when N is large. - Non-symmetric aggregators: Using order-dependent reductions (e.g., RNN over neighbors) in a set context breaks invariance; if used, justify and measure impact.

Key Formulas

General Message Passing Update

h_{v}^{(k + 1)} = ϕ (h_{v}^{(k)}, □_{u \in N (v)} ψ (h_{v}^{(k)}, h_{u}^{(k)}, e_{uv}))

Explanation: Each node v collects messages from neighbors u using a message function $ψ,$ aggregates them with a symmetric operator (sum/mean/max), and applies an update $φ .$ This captures local interactions while remaining permutation invariant over neighbors.

PointNet Set Function

f ({x_{i}}_{i = 1}^{n}) = γ (POOL_{i = 1}^{n} h (x_{i}))

Explanation: PointNet models permutation-invariant set functions by transforming each element with h (shared MLP) and then applying a symmetric pooling before a final mapping $γ .$ The pooling ensures invariance to input order.

GCN Layer

H^{(k + 1)} = σ (\tilde{D}^{- 1/2} \tilde{A} \tilde{D}^{- 1/2} H^{(k)} W^{(k)})

Explanation: A graph convolution layer mixes neighbor features using the normalized adjacency $\tilde{A}$ = A + I and degree $\tilde{D}$ . The normalization stabilizes feature scales across nodes of different degrees.

EdgeConv (DGCNN)

m_{ij} = MLP ([h_{i}, h_{j} - h_{i}]), h_{i}^{'} = AGG_{j \in N (i)} m_{ij}

Explanation: Messages depend on relative differences $h_{j}$ − $h_{i}$ to encode local geometry; features are aggregated with a symmetric operator like max. This design is effective for point clouds.

Global Max Pooling

g_{j} = i \in {1, \dots, n} max h_{ij}

Explanation: The j-th component of the global descriptor is the maximum value across points for that feature. Max is symmetric, providing permutation invariance.

MPNN Complexity (Typical)

Time per layer \approx O (EF + N F^{2})

Explanation: Computing messages and aggregations scales with edges E and feature size F; linear transforms often cost N $F^{2}$ if dense. In sparse settings with small F, the O(EF) term dominates.

k-NN Neighborhood

N (i) \subseteq V, ∣ N (i) ∣ = k arg min j \in N (i) \sum ∥ x_{i} - x_{j} ∥_{2}^{2}

Explanation: k-NN selects k nearest neighbors minimizing squared distances. Naively computing all pairwise distances is O( $N^{2}$ ), but spatial indexes can reduce cost.

Permutation Invariance via Permutation Matrices

f (PX) = f (X), \forall permutation matrices P

Explanation: For a set function f on point sets represented as matrices X, invariance means permuting rows by P does not change the output. Symmetric pooling operations satisfy this property.

Complexity Analysis

Let N be the number of points/nodes, E the number of edges, and F the feature dimension. A single message passing layer typically computes, for each edge (u, v), a message

ψ (h_{u},

h_{v}

e_{u} v

) in O(F) to O(

F^{2}

), then aggregates per node using a symmetric operator. This yields O(EF) time for message formation and aggregation if ψ is linear in F; with an MLP of hidden width H, the cost becomes O(EFH). Node-wise updates φ add O(NFH). Memory is O(NF + E) to store features and sparse edges; storing messages explicitly increases memory to O(EF), which can be avoided by streaming aggregation. For PointNet with shared MLP of widths

F \to H 1

→ H2 and global pooling, the per-point MLP costs O(N(FH1 + H1H2)) and the global max-pool is O(NH2). This is linear in N and independent of input ordering. Constructing neighborhoods is often the bottleneck: naive k-NN is O(

N^{2}

d) for d-dimensional coordinates, while kd-trees or spatial hashing reduce expected cost to O(N log N) for fixed d. Stacking K message passing layers increases the receptive field to K hops and scales time roughly linearly with K: O(K(EFH + NFH)). Over-smoothing or exploding degrees can be mitigated with normalization (e.g.,

D^{- 1/2} A D^{- 1/2}

), residual connections, and bounded k. In practice, choose small k (e.g., 16–32), moderate F (32–128), and stream messages to keep memory near O(NF).

Code Examples

PointNet-style permutation-invariant forward pass (shared MLP + global max-pooling)

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 // Simple Linear layer: y = x W + b, where x is 1xF_in, W is F_in x F_out
5 struct Linear {
6     int in_f, out_f;
7     vector<float> W; // row-major: in_f x out_f
8     vector<float> b; // out_f
9     Linear(int in_f, int out_f, mt19937 &rng): in_f(in_f), out_f(out_f), W(in_f*out_f), b(out_f){
10         uniform_real_distribution<float> dist(-0.1f, 0.1f);
11         for (auto &w : W) w = dist(rng);
12         for (auto &x : b) x = dist(rng);
13     }
14     // forward for a single feature vector x (size in_f)
15     vector<float> forward(const vector<float>& x) const {
16         vector<float> y(out_f, 0.0f);
17         for (int j = 0; j < out_f; ++j) {
18             float sum = b[j];
19             for (int i = 0; i < in_f; ++i) sum += x[i] * W[i*out_f + j];
20             y[j] = sum;
21         }
22         return y;
23     }
24 };
25 
26 static inline void relu_inplace(vector<float>& v){ for (auto &x : v) x = max(0.0f, x); }
27 
28 // Apply a shared MLP to each point independently, then global max-pool across points
29 int main(){
30     ios::sync_with_stdio(false);
31     cin.tie(nullptr);
32 
33     // Create a dummy point cloud: N points with 3D coords
34     int N = 5; // small example
35     vector<array<float,3>> points = {
36         {0.1f, 0.2f, 0.3f}, {1.0f, -0.5f, 0.2f}, {0.0f, 0.0f, 0.0f},
37         {0.3f, 0.1f, 0.9f}, {-0.2f, 0.4f, -0.1f}
38     };
39 
40     // Shared MLP: 3 -> 16 -> 32 (per-point features)
41     mt19937 rng(42);
42     Linear l1(3, 16, rng);
43     Linear l2(16, 32, rng);
44 
45     // Global max-pooled feature initialized to -inf per channel
46     vector<float> global_feat(32, -numeric_limits<float>::infinity());
47 
48     // Forward pass: per-point MLP then update global max
49     for (int i = 0; i < N; ++i){
50         // point to vector<float>
51         vector<float> x = {points[i][0], points[i][1], points[i][2]};
52         auto h1 = l1.forward(x);
53         relu_inplace(h1);
54         auto h2 = l2.forward(h1);
55         relu_inplace(h2);
56         // max-pool
57         for (int j = 0; j < (int)h2.size(); ++j)
58             global_feat[j] = max(global_feat[j], h2[j]);
59     }
60 
61     // Classification head: 32 -> 4 logits (e.g., 4 classes)
62     Linear head(32, 4, rng);
63     auto logits = head.forward(global_feat);
64 
65     cout << fixed << setprecision(4);
66     cout << "Global feature (first 8 dims): ";
67     for (int j = 0; j < 8; ++j) cout << global_feat[j] << (j+1<8? ' ' : '\n');
68     cout << "Logits: ";
69     for (int j = 0; j < (int)logits.size(); ++j) cout << logits[j] << (j+1<(int)logits.size()? ' ' : '\n');
70 
71     return 0;
72 }
73

This program implements the PointNet idea: a shared MLP maps each point independently to a higher-dimensional feature, and a symmetric global max-pooling aggregates over all points to obtain a permutation-invariant global descriptor. A final linear layer produces logits for classification. Because max-pooling is symmetric, reordering the input points leaves the global feature and logits unchanged.

Time: O(N(FH1 + H1H2) + NH2 + H2C), approximately linear in the number of points NSpace: O(H2 + parameters), dominated by the global feature and model weights

One message passing layer on a mesh/graph with mean aggregation

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 struct Linear {
5     int in_f, out_f; vector<float> W, b;
6     Linear(int in_f, int out_f, mt19937 &rng): in_f(in_f), out_f(out_f), W(in_f*out_f), b(out_f){
7         uniform_real_distribution<float> d(-0.1f, 0.1f);
8         for (auto &w: W) w = d(rng); for (auto &x: b) x = d(rng);
9     }
10     vector<float> forward(const vector<float>& x) const{
11         vector<float> y(out_f, 0.0f);
12         for (int j=0;j<out_f;++j){ float s=b[j]; for (int i=0;i<in_f;++i) s += x[i]*W[i*out_f+j]; y[j]=s; }
13         return y;
14     }
15 };
16 static inline void relu_inplace(vector<float>& v){ for (auto &x: v) x = max(0.0f, x); }
17 
18 // Perform one message passing step: h'_v = ReLU( W_self h_v + W_neigh mean_{u in N(v)} h_u )
19 int main(){
20     ios::sync_with_stdio(false);
21     cin.tie(nullptr);
22 
23     // Example graph: 4 nodes, undirected edges (0-1-2-3 forms a path)
24     int N = 4, F = 8, Fout = 8;
25     vector<vector<int>> nbr = {{1},{0,2},{1,3},{2}}; // adjacency list
26 
27     // Node features (random init for demo)
28     mt19937 rng(123);
29     uniform_real_distribution<float> d(-1.0f, 1.0f);
30     vector<vector<float>> H(N, vector<float>(F));
31     for (int i=0;i<N;++i) for (int j=0;j<F;++j) H[i][j] = d(rng);
32 
33     Linear W_self(F, Fout, rng);
34     Linear W_neigh(F, Fout, rng);
35 
36     vector<vector<float>> Hnext(N, vector<float>(Fout, 0.0f));
37 
38     for (int v=0; v<N; ++v){
39         // mean of neighbor features (with self-loop fallback if isolated)
40         vector<float> meanF(F, 0.0f);
41         int deg = (int)nbr[v].size();
42         if (deg == 0){ meanF = H[v]; deg = 1; }
43         else{
44             for (int u : nbr[v]){
45                 for (int j=0;j<F;++j) meanF[j] += H[u][j];
46             }
47             for (int j=0;j<F;++j) meanF[j] /= float(deg);
48         }
49         auto a = W_self.forward(H[v]);
50         auto b = W_neigh.forward(meanF);
51         for (int j=0;j<Fout;++j) Hnext[v][j] = a[j] + b[j];
52         relu_inplace(Hnext[v]);
53     }
54 
55     cout << fixed << setprecision(4);
56     for (int i=0;i<N;++i){
57         cout << "h'_" << i << ": ";
58         for (int j=0;j<Fout;++j) cout << Hnext[i][j] << (j+1<Fout? ' ' : '\n');
59     }
60     return 0;
61 }
62

This code demonstrates a simple spatial graph convolution via message passing on a mesh/graph: each node mixes its own feature with the mean of its neighbors’ features, followed by ReLU. The adjacency list can come from mesh connectivity or a constructed k-NN graph for point clouds. The mean aggregator is symmetric and ensures permutation invariance over neighbor order.

Time: O(EF + NFoutF) for aggregation and linear maps; with fixed F and Fout, it is O(E + N)Space: O(NF + E) for features and adjacency

Naive k-NN graph + EdgeConv-like layer for point clouds

1 #include <bits/stdc++.h>
2 using namespace std;
3 
4 struct Linear { int in_f, out_f; vector<float> W, b; Linear(int in_f,int out_f,mt19937 &rng):in_f(in_f),out_f(out_f),W(in_f*out_f),b(out_f){uniform_real_distribution<float>d(-0.1f,0.1f);for(auto&w:W)w=d(rng);for(auto&x:b)x=d(rng);} vector<float> forward(const vector<float>& x) const{ vector<float> y(out_f,0.0f); for(int j=0;j<out_f;++j){ float s=b[j]; for(int i=0;i<in_f;++i) s+=x[i]*W[i*out_f+j]; y[j]=s;} return y; } };
5 static inline void relu_inplace(vector<float>& v){ for(auto &x:v) x=max(0.0f,x); }
6 
7 // Build k-NN graph naively in O(N^2)
8 vector<vector<int>> build_knn(const vector<array<float,3>>& pts, int k){
9     int N = (int)pts.size();
10     vector<vector<int>> nbr(N);
11     for(int i=0;i<N;++i){
12         vector<pair<float,int>> dist; dist.reserve(N-1);
13         for(int j=0;j<N;++j){ if(i==j) continue; float dx=pts[i][0]-pts[j][0]; float dy=pts[i][1]-pts[j][1]; float dz=pts[i][2]-pts[j][2]; float d2=dx*dx+dy*dy+dz*dz; dist.emplace_back(d2,j);}        
14         nth_element(dist.begin(), dist.begin()+min(k,(int)dist.size())-1, dist.end());
15         int kk = min(k, (int)dist.size());
16         nbr[i].reserve(kk);
17         for(int t=0;t<kk;++t) nbr[i].push_back(dist[t].second);
18     }
19     return nbr;
20 }
21 
22 int main(){
23     ios::sync_with_stdio(false); cin.tie(nullptr);
24     // Dummy point cloud
25     vector<array<float,3>> pts = {{0,0,0},{0.1f,0,0.02f},{0.2f,0.05f,0},{-0.1f,0.02f,0.03f},{0.05f,-0.05f,0.01f}};
26     int N = (int)pts.size();
27 
28     // Initial per-point features: here just coordinates (3D)
29     vector<vector<float>> H(N, vector<float>(3));
30     for(int i=0;i<N;++i){ H[i][0]=pts[i][0]; H[i][1]=pts[i][1]; H[i][2]=pts[i][2]; }
31 
32     // k-NN graph
33     int k = 2; // small for demo
34     auto nbr = build_knn(pts, k);
35 
36     // EdgeConv message: m_ij = MLP([h_i, h_j - h_i]) with MLP 6->16->8
37     mt19937 rng(7);
38     Linear e1(6,16,rng); Linear e2(16,8,rng);
39 
40     vector<vector<float>> Hnext(N, vector<float>(8, -numeric_limits<float>::infinity())); // max-aggregation init
41 
42     for(int i=0;i<N;++i){
43         for(int j: nbr[i]){
44             // build [h_i, h_j - h_i]
45             vector<float> x(6);
46             for(int t=0;t<3;++t){ x[t]=H[i][t]; x[3+t]=H[j][t]-H[i][t]; }
47             auto h = e1.forward(x); relu_inplace(h); h = e2.forward(h); relu_inplace(h);
48             // max over neighbors
49             for(int c=0;c<8;++c) Hnext[i][c] = max(Hnext[i][c], h[c]);
50         }
51         // If a node has no neighbors (shouldn't here), fallback to zeros
52         for(int c=0;c<8;++c) if(!isfinite(Hnext[i][c])) Hnext[i][c]=0.0f;
53     }
54 
55     cout << fixed << setprecision(4);
56     for(int i=0;i<N;++i){
57         cout << "EdgeConv h'_"<<i<<": ";
58         for(int c=0;c<8;++c) cout << Hnext[i][c] << (c+1<8? ' ':'\n');
59     }
60     return 0;
61 }
62

This program constructs a naive k-NN graph for a point cloud (O(N^2)) and runs one EdgeConv-like message passing layer. Messages depend on both the point’s current features and relative differences to neighbors, then are aggregated with max (a symmetric operator). EdgeConv captures local geometric patterns and is commonly used for segmentation and classification in point clouds.

Time: O(N^2 d) to build k-NN naively (d=3 here) and O(EH) for the EdgeConv MLP (E ≈ kN)Space: O(NF + E) for features and neighborhood lists

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	// Simple Linear layer: y = x W + b, where x is 1xF_in, W is F_in x F_out
5	struct Linear {
6	int in_f, out_f;
7	vector<float> W; // row-major: in_f x out_f
8	vector<float> b; // out_f
9	Linear(int in_f, int out_f, mt19937 &rng): in_f(in_f), out_f(out_f), W(in_f*out_f), b(out_f){
10	uniform_real_distribution<float> dist(-0.1f, 0.1f);
11	for (auto &w : W) w = dist(rng);
12	for (auto &x : b) x = dist(rng);
13	}
14	// forward for a single feature vector x (size in_f)
15	vector<float> forward(const vector<float>& x) const {
16	vector<float> y(out_f, 0.0f);
17	for (int j = 0; j < out_f; ++j) {
18	float sum = b[j];
19	for (int i = 0; i < in_f; ++i) sum += x[i] * W[i*out_f + j];
20	y[j] = sum;
21	}
22	return y;
23	}
24	};
25
26	static inline void relu_inplace(vector<float>& v){ for (auto &x : v) x = max(0.0f, x); }
27
28	// Apply a shared MLP to each point independently, then global max-pool across points
29	int main(){
30	ios::sync_with_stdio(false);
31	cin.tie(nullptr);
32
33	// Create a dummy point cloud: N points with 3D coords
34	int N = 5; // small example
35	vector<array<float,3>> points = {
36	{0.1f, 0.2f, 0.3f}, {1.0f, -0.5f, 0.2f}, {0.0f, 0.0f, 0.0f},
37	{0.3f, 0.1f, 0.9f}, {-0.2f, 0.4f, -0.1f}
38	};
39
40	// Shared MLP: 3 -> 16 -> 32 (per-point features)
41	mt19937 rng(42);
42	Linear l1(3, 16, rng);
43	Linear l2(16, 32, rng);
44
45	// Global max-pooled feature initialized to -inf per channel
46	vector<float> global_feat(32, -numeric_limits<float>::infinity());
47
48	// Forward pass: per-point MLP then update global max
49	for (int i = 0; i < N; ++i){
50	// point to vector<float>
51	vector<float> x = {points[i][0], points[i][1], points[i][2]};
52	auto h1 = l1.forward(x);
53	relu_inplace(h1);
54	auto h2 = l2.forward(h1);
55	relu_inplace(h2);
56	// max-pool
57	for (int j = 0; j < (int)h2.size(); ++j)
58	global_feat[j] = max(global_feat[j], h2[j]);
59	}
60
61	// Classification head: 32 -> 4 logits (e.g., 4 classes)
62	Linear head(32, 4, rng);
63	auto logits = head.forward(global_feat);
64
65	cout << fixed << setprecision(4);
66	cout << "Global feature (first 8 dims): ";
67	for (int j = 0; j < 8; ++j) cout << global_feat[j] << (j+1<8? ' ' : '\n');
68	cout << "Logits: ";
69	for (int j = 0; j < (int)logits.size(); ++j) cout << logits[j] << (j+1<(int)logits.size()? ' ' : '\n');
70
71	return 0;
72	}
73

1	#include <bits/stdc++.h>
2	using namespace std;
3
4	struct Linear { int in_f, out_f; vector<float> W, b; Linear(int in_f,int out_f,mt19937 &rng):in_f(in_f),out_f(out_f),W(in_fout_f),b(out_f){uniform_real_distribution<float>d(-0.1f,0.1f);for(auto&w:W)w=d(rng);for(auto&x:b)x=d(rng);} vector<float> forward(const vector<float>& x) const{ vector<float> y(out_f,0.0f); for(int j=0;j<out_f;++j){ float s=b[j]; for(int i=0;i<in_f;++i) s+=x[i]W[i*out_f+j]; y[j]=s;} return y; } };
5	static inline void relu_inplace(vector<float>& v){ for(auto &x:v) x=max(0.0f,x); }
6
7	// Build k-NN graph naively in O(N^2)
8	vector<vector<int>> build_knn(const vector<array<float,3>>& pts, int k){
9	int N = (int)pts.size();
10	vector<vector<int>> nbr(N);
11	for(int i=0;i<N;++i){
12	vector<pair<float,int>> dist; dist.reserve(N-1);
13	for(int j=0;j<N;++j){ if(i==j) continue; float dx=pts[i][0]-pts[j][0]; float dy=pts[i][1]-pts[j][1]; float dz=pts[i][2]-pts[j][2]; float d2=dxdx+dydy+dz*dz; dist.emplace_back(d2,j);}
14	nth_element(dist.begin(), dist.begin()+min(k,(int)dist.size())-1, dist.end());
15	int kk = min(k, (int)dist.size());
16	nbr[i].reserve(kk);
17	for(int t=0;t<kk;++t) nbr[i].push_back(dist[t].second);
18	}
19	return nbr;
20	}
21
22	int main(){
23	ios::sync_with_stdio(false); cin.tie(nullptr);
24	// Dummy point cloud
25	vector<array<float,3>> pts = {{0,0,0},{0.1f,0,0.02f},{0.2f,0.05f,0},{-0.1f,0.02f,0.03f},{0.05f,-0.05f,0.01f}};
26	int N = (int)pts.size();
27
28	// Initial per-point features: here just coordinates (3D)
29	vector<vector<float>> H(N, vector<float>(3));
30	for(int i=0;i<N;++i){ H[i][0]=pts[i][0]; H[i][1]=pts[i][1]; H[i][2]=pts[i][2]; }
31
32	// k-NN graph
33	int k = 2; // small for demo
34	auto nbr = build_knn(pts, k);
35
36	// EdgeConv message: m_ij = MLP([h_i, h_j - h_i]) with MLP 6->16->8
37	mt19937 rng(7);
38	Linear e1(6,16,rng); Linear e2(16,8,rng);
39
40	vector<vector<float>> Hnext(N, vector<float>(8, -numeric_limits<float>::infinity())); // max-aggregation init
41
42	for(int i=0;i<N;++i){
43	for(int j: nbr[i]){
44	// build [h_i, h_j - h_i]
45	vector<float> x(6);
46	for(int t=0;t<3;++t){ x[t]=H[i][t]; x[3+t]=H[j][t]-H[i][t]; }
47	auto h = e1.forward(x); relu_inplace(h); h = e2.forward(h); relu_inplace(h);
48	// max over neighbors
49	for(int c=0;c<8;++c) Hnext[i][c] = max(Hnext[i][c], h[c]);
50	}
51	// If a node has no neighbors (shouldn't here), fallback to zeros
52	for(int c=0;c<8;++c) if(!isfinite(Hnext[i][c])) Hnext[i][c]=0.0f;
53	}
54
55	cout << fixed << setprecision(4);
56	for(int i=0;i<N;++i){
57	cout << "EdgeConv h'_"<<i<<": ";
58	for(int c=0;c<8;++c) cout << Hnext[i][c] << (c+1<8? ' ':'\n');
59	}
60	return 0;
61	}
62