MLGCN: an ultra efficient graph convolutional neural model for 3D point cloud analysis

Kaleem Siddiqi, Mohammad Khodadad, Ali Shiraee Kasmaee, Hamidreza Mahyar, Morteza RezanejadFrontiers Artif. Intell 2024 · DOI

Introduction

Analyzing 3D point clouds—the raw data captured by LiDAR sensors and depth cameras—is a fundamental challenge in computer vision. Unlike 2D images, which are structured in regular grids, point clouds are sparse, unordered, and vary in density. While standard Convolutional Neural Networks (CNNs) excel at image processing, they cannot be applied directly to point clouds without "voxelization" (converting points into a 3D grid). This conversion often leads to significant information loss or prohibitive memory requirements.

Graph Neural Networks (GNNs) have emerged as a more natural alternative, treating points as nodes in a graph to capture geometric relationships. However, traditional GNNs are computationally expensive. They typically recompute the $k$-nearest neighbors (KNN) for every point at every layer, creating a massive processing bottleneck. Additionally, deep GNNs often suffer from "over-smoothing," where features across the graph become indistinguishable. The Multi-level Graph Convolutional Network (MLGCN) addresses these challenges by providing an ultra-efficient architecture designed for resource-constrained edge devices.

Methodology: Efficiency through Multi-Level Locality

The core innovation of MLGCN lies in its departure from deep, sequential stacks in favor of a shallow, multi-branch architecture. The model utilizes several key strategies to minimize computational overhead:

1. Shared KNN Graphs

In a typical GNN, finding neighbors is the most expensive operation. MLGCN optimizes this by computing the KNN graph once for a specific locality level ($k$) and reusing that graph across multiple Graph Convolution (GCN) blocks. This "compute once, use many" strategy drastically reduces the number of floating-point operations (FLOPs).

2. Multi-level Locality

Instead of a single deep path, the model runs several GNN branches in parallel. Each branch uses a different $k$ value (for example, $k=0$ for global features, and $k=15$ or $k=63$ for local details). This allows the network to simultaneously capture fine-grained textures and the overall global shape of an object.

3. Shallow and Wide Architecture

By keeping individual branches shallow, MLGCN avoids the over-smoothing problem common in deep GNNs. This design also maintains a small memory footprint, making it ideal for mobile phones and robotics platforms.

4. Information Placement

The model employs a specialized module to propagate features across precomputed graph edges. This ensures that local geometric information is effectively integrated before the final classification or segmentation layers.

Experimental Evaluation

The authors evaluated MLGCN on two primary benchmarks in the 3D vision community:

  • ModelNet-40: A collection of 12,311 CAD models across 40 categories (e.g., chairs, airplanes) used for object classification.
  • ShapeNetPart: A dataset of 16,881 3D shapes from 16 classes used for part segmentation (e.g., identifying the wing versus the body of an airplane).

Performance and Efficiency

The quantitative results highlight a significant leap in efficiency:

  • Computational Reduction: The "Light MLGCN" variant requires only 1.3 million FLOPs. In comparison, the popular DGCNN model requires 1,300 million FLOPs—a 1,000x reduction.
  • Model Size: The model occupies just 1.5 MB of memory, whereas competing architectures like PointMLP can exceed 100 MB.
  • Accuracy: Despite its size, MLGCN achieved 90.7% accuracy on ModelNet-40. While slightly lower than the absolute state-of-the-art (94.5%), the 1200x reduction in FLOPs compared to top performers makes it significantly more practical for real-world deployment.
  • Robustness: The model demonstrated remarkable resilience to low-resolution data, maintaining 83.7% accuracy even when input was downsampled to just 128 points.

Discussion and Future Work

MLGCN demonstrates that the primary bottleneck in 3D GNNs is often the graph reconstruction process rather than the convolution mathematics. By freezing the graph structure within blocks and prioritizing parallelism over depth, the model achieves high performance with minimal resources.

However, some challenges remain. There is still a ~4% accuracy gap between this lightweight model and the most complex, heavy-duty models. Furthermore, while MLGCN excels at single-object classification, extending this architecture to large-scale scene understanding (such as entire rooms or urban environments) is a necessary next step. Future research may also focus on hardware-specific optimizations, such as custom CUDA kernels or mobile DSP implementations, to further translate these theoretical FLOP reductions into real-world speed gains.

Summary updated

BibTeX
@article{siddiqi2024mlgcn,
  author = {Kaleem Siddiqi and Mohammad Khodadad and Ali Shiraee Kasmaee and Hamidreza Mahyar and Morteza Rezanejad},
  title = {{MLGCN: an ultra efficient graph convolutional neural model for 3D point cloud analysis}},
  journal = {Frontiers Artif. Intell},
  year = {2024},
  doi = {10.3389/frai.2024.1439340},
}
Figure