MANBO: Mamba-Based Lightweight Attention Network with Priority-Bridged Ordering for Point Cloud Processing

Abstract

Selective state space models (SSMs) enable efficient long-range dependency modeling across language, vision, and 3D domains. However, because SSMs are optimized for sequential processing, they handle spatially irregular inputs such as point clouds poorly. We propose MANBO, which couples a graph-based node priority selection mechanism with the Mamba block to model long-range context while preserving local relational structure. A lightweight graph network learns semantic relations among point patches and derives a priority score for each patch from the concentration of its local attention. A priority–space integration strategy then orders patches by both spatial proximity and the attention-derived priority, and we extend the reconstruction scope of masked pre-training to couple global contextual learning with fine-grained local reconstruction. On ScanObjectNN, ModelNet40, and ShapeNetPart, MANBO achieves 94.76% (OBJ-BG), 93.2%, and 86.3 mIoU, respectively, with consistent improvements over Mamba-based baselines. These results indicate that jointly addressing serialization and representation learning is an effective way to apply SSMs to object-level point cloud understanding.

1. Introduction

Three-dimensional point cloud data processing is a 3D vision task applied in diverse fields such as autonomous driving [1,2], computer vision [3], robotics [4], and virtual reality [5]. These 3D data provide precise spatial information that can be acquired directly from sensors, but they are difficult to process due to their unordered structure and uneven density. Recently, deep learning-based approaches [6,7] have achieved remarkable success, leading to extensive research efforts to apply them to point cloud processing. In particular, Transformer architectures have been extensively explored for point cloud processing, as their permutation-invariant self-attention mechanism naturally handles the unordered nature of point clouds [8,9,10]. However, self-attention requires computing pairwise weights between all tokens, resulting in $\mathcal{O}\left(N^2\right)$ complexity, which significantly degrades computational efficiency for large-scale inputs (e.g., thousands of points). Accordingly, researchers have explored lightweight Transformer architectures based on sparse attention, including BigBird [11], Performers [12], and Sparse Transformers [13]. In this context, recently proposed structured state space sequence model (S4)-based methods [14] such as Mamba [15] have attracted attention as promising alternatives to Transformers. Nevertheless, few studies have investigated the potential of applying S4 approaches, such as Mamba, to 3D point clouds to date. Existing studies on PointMamba [16] and PCM [17] adopted coordinate sorting or 2D grid-based traversal methods to convert unordered point clouds into sequences. While such approaches offer advantages in terms of simplicity and efficiency, they suffer from limitations. That is, traversal orders vary depending on the viewpoint, and spatially unrelated points may be placed as adjacent tokens, thereby degrading semantic consistency. To address these limitations, SI-Mamba [18] proposed a viewpoint-invariant traversal using the eigenvectors of the graph Laplacian; however, the high computational cost of eigendecomposition and the insufficient incorporation of local geometric structures make it difficult to maintain Mamba’s simplicity and efficiency. Therefore, to handle the unordered and structural characteristics of object-level point clouds while preserving Mamba’s inherent efficiency, this study proposes the following three strategies.

1.

Using a lightweight proximity graph (LMGA), the model learns local relations and preserves pointwise connectivity and structural consistency, enabling effective neighborhood aggregation and stable local representation learning.

2.

We designed a local priority serialization strategy (PAOS) that constructs the sequence order according to each point’s relative priority. This approach improves spatial consistency and traversal stability in Mamba’s sequence processing, allowing the model to maintain a more coherent ordering under varying viewpoints and spatial configurations (Appendix C).

3.

We also present a composite-ratio masking (CRM) scheme that trains point clouds with multiple masking ratios in parallel and balances reconstruction losses by difficulty, achieving more robust self-supervised pretraining.

2. Related Work

2.1. Deep Learning for Point Clouds

Deep learning has become a core paradigm for point cloud understanding, where PointNet [6] and PointNet++ [7] directly process raw point sets without preprocessing, establishing the foundation for hierarchical global–local feature extraction. Graph-based methods [19,20] represent unordered point sets as dynamic graphs to more precisely model geometric structure. DGCNN [21] learns local geometry via k-nearest neighbors and edge convolution, while GACNet [22] and DGACN [23] employ graph attention to learn neighbor interaction weights, enabling more flexible local representations and adaptive information aggregation. Transformer-based frameworks [24,25] treat point clouds as sequences or sets and directly model global interactions via self-attention. Point-Transformer (v1, v2, v3) [26,27,28] and OctFormer [29] have evolved toward hierarchically integrating local and global information, allowing more refined modeling of complex 3D structures. Recently, self-supervised pre-training based on masked point modeling [30,31,32], which pre-trains Transformers to learn robust representations without large-scale labels, has gained significant attention. Point-MAE [9] applies the Masked Autoencoder (MAE) framework [33] to 3D point clouds, proposing a self-supervised pre-training scheme that reconstructs irregular point patches. Point-M2AE [10] improves Point-MAE with fine-grained local representation learning.

2.2. State Space Models

State-space models (SSMs) have long served as a fundamental framework in control theory and signal processing for modeling dynamic systems. They efficiently learn long-range dependencies by accumulating contextual information from input sequences into latent states and updating them sequentially. Recently, as SSMs have been extended to deep learning, the Linear State-Space Layer (LSSL) [34], based on the HiPPO [35] operator, introduced a continuous-time memory representation but suffered from high computational complexity. S4 [14] improved training stability and efficiency through parameter normalization and complex diagonalization, while subsequent models such as H3 [36], GSSM [37], Hyena [38], and RWKV [39] achieved Transformer-level long-range dependency modeling with linear-time complexity. Mamba [15] recently achieved efficient linear sequence modeling with a data-dependent selection mechanism, outperforming Transformers on various benchmarks. Mamba’s success is extending beyond language [40,41] and vision [42,43] to 3D data processing. Vision Mamba [44] compressed visual representations through a bidirectional SSM, while VMamba [45] introduced a Cross-Scan Module that performs 1D selective scanning over 2D images, efficiently modeling a global receptive field. In contrast, research on SSMs in 3D vision, particularly in the point cloud domain, remains in its early stages. PointMamba [16] proposes a simple token ordering scheme that repositions point tokens onto a 3D grid and arranges them into a 1D sequence, whereas SI-Mamba [18] extends Mamba by defining a spectral traversal that constructs the sequence order using graph-Laplacian-based spectral coordinates. More recently, ZigzagPointMamba [46] serializes tokens along zigzag paths on the three orthogonal planes, which remains a coordinate-driven traversal. Building on these approaches, our method enhances the ordering quality of point clouds and strengthens the continuity and expressiveness of local structures.

3. Materials and Methods

MANBO is a scalable Mamba-based model designed to learn regional correlations via a lightweight multi-graph network. This framework is designed to achieve both the efficiency of sequence learning and the expressive power of graph structures by converting unstructured point clouds into sequential token sequences. To begin with, we briefly introduce the mathematical foundations of the SSM and graph attention that support the proposed design. We then propose a Lightweight Multi-Graph Attention (LMGA) strategy that leverages a lightweight multi-graph topology to aggregate local relational features, preserving the local structure and contextual relationships of point clouds while maintaining computational efficiency. Thereafter, we introduce the Priority-Aware Ordering Strategy (PAOS), which injects the attention-derived priority into the traversal process to convert unstructured point sets into a stable serial structure, enabling order consistency and long-range contextual propagation. Finally, we propose a Composite-Ratio Masking (CRM) strategy to address the problem of limited overlapping regions in masked autoencoders.

3.1. Preliminaries

3.1.1. State Space Models (SSMs)

The state space model interprets sequential data as a dynamic system to describe how the input $x\left(t\right)\in {\mathbb{R}}^N$ transforms into a state $h\left(t\right)\in {\mathbb{R}}^N$ over time, resulting in the output $y\left(t\right)\in {\mathbb{R}}^N$. This relationship is generally expressed by the following linear differential equation.

$$\dot{h}\left(t\right)=Ah\left(t\right)+Bx\left(t\right),y\left(t\right)=Ch\left(t\right)+Dx\left(t\right)$$

(1)

where $x\left(t\right)$ denotes the input signal, $y\left(t\right)$ represents the output and $\dot{h}\left(t\right)$ is the time derivative of the state vector $h\left(t\right)$, which describes the state transition of the system. A, B, C, and D are constant system matrices. However, since data in real-world environments are mostly discrete rather than continuous, the system described in Equation (1) needs to be discretized to be applicable for practical computation.

$$\begin{array}{cc}\hfill h_k& =\overline{A}{h}_{k-1}+\overline{B}{x}_k,\hfill \\ \hfill y_k& =\overline{C}{h}_k+\overline{D}{x}_k\hfill \end{array}$$

(2)

$\overline{A}\in {\mathbb{R}}^{N\times N}$, and $\overline{B}$, $\overline{C}$, $\overline{D}\in {\mathbb{R}}^{N\times 1}$ are learnable transition parameters obtained through the discretization process, which connect each state $h_k$ to the previous state $h_{k-1}$ and the input $x_k$. The $\tilde{D}$ term can be used as a residual connection, but for consistency with prior work, we do not include it in this study. To convert a continuous signal $x\left(t\right)$ into a discrete sequence, a sampling process must be performed at regular time intervals $\Delta$. Thus, we define $x_k=x(k\Delta )$, and the continuous-time matrices $A,B,C,D$ in Equation (1) are transformed as follows:

$$\overline{A}=e^{A\Delta },\overline{B}=A^{-1}(e^{A\Delta }-I)B,\overline{C}=C,$$

(3)

However, such fixed dynamic structures cannot fully capture variations in the input signal or contextual correlations between time points. As a result, the constant parameters A, B, and C cannot dynamically perform selective retention or discarding of information, limiting the model’s ability to capture contextual dependencies across the sequence. To address this issue, we use Mamba’s selective state update mechanism in this study [15].

3.1.2. Graph Representation of Point Clouds

A point cloud is an unstructured set of points that is modeled as a graph $G=(V,E)$ to explicitly represent spatial relationships among neighboring points. The input point cloud is represented as a set of coordinates $C={\left\{c_i\right\}}_{i=1}^N$ and the corresponding set of features $F={\left\{f_i\right\}}_{i=1}^N$. The neighborhood of each center point $c_i$ is defined as $N_{\left(i\right)}=\mathrm{KNN}(c_i,N_n)$ and the interaction weights among neighboring points are computed using learnable parameters in the attention mechanism. This graph structure is not limited to representing distance-based connectivity but is further extended to capture representational differences among points. For each center point $c_i$, its neighboring points $c_j\in N\left(i\right)$ are compared in both spatial and feature domains, where the relative position difference ($c_i-c_j$) and feature difference ($f_i-f_j$) are concatenated to form the edge representation $e_{ij}\in {\mathbb{R}}^d$. The edge representation $e_{ij}$ serves as the basic unit for computing point-to-point interactions in the subsequent attention module. In this study, both point and edge representations are linearly projected into the Query–Key–Value space to serve as the input of the attention computation [47]:

$$Q_i=W_Q{f}_i,K_{ij}=W_K{e}_{ij},V_{ij}=W_V{e}_{ij}.$$

(4)

Here, $W_Q\in {\mathbb{R}}^{d_q\times d}$ and $W_K,W_V\in {\mathbb{R}}^{d_k\times d_e}$ are learnable parameter matrices. This linear transformation maps the feature space of each point into an ordered form, enabling attention-based relational learning while preserving local contextual information.

3.2. Point Patches

To enable efficient processing, local patch units are constructed from the input point cloud $P={\left\{p_i\right\}}_{i=1}^N\subset {\mathbb{R}}^3$. We first apply Farthest Point Sampling (FPS) to select a set of center points $C={\left\{c_i\right\}}_{i=1}^{N_c}\subset P$ with a uniform spatial distribution. For each center point $c_i$, we perform a KNN operation as defined in Section 3.1.2 to find $N_n$ neighboring points. Each local patch is thus composed of a center point and its neighbors, with the patch size defined as $1+N_n$. Within each patch, the edge features $e_{ij}$ are encoded through a nonlinear embedding function, and a mean pooling operation is applied to obtain a single patch representation $f_i$. As a result, the set of patch tokens $F={\left\{f_i\right\}}_{i=1}^{N_c}$ preserves both local geometric and contextual information, which is subsequently utilized for hierarchical sequential ordering in the LMGA (Section 3.3) and PAOS (Section 3.4) stages.

3.3. Lightweight Multi-Graph Attention (LMGA)

Existing Mamba-based point cloud models, such as PointMamba [16] and PCM [17], convert unstructured point clouds into sequential forms by employing coordinate sorting or 3D grid-based traversal methods. Although this approach offers advantages in terms of simplicity and efficiency, it inherently suffers from the following fundamental limitations, as mentioned earlier: (1) The traversal order is view-dependent, meaning that even the same object produces different input sequences depending on the observation viewpoint or rotation. (2) Spatially unrelated points may be arranged as adjacent tokens, which disrupts semantic consistency. To mitigate these limitations, SI-Mamba [18] defines a view-invariant order using the eigenvectors of the graph Laplacian. However, due to the computational complexity of eigendecomposition and its limited ability to capture local geometric structures, this approach undermines the Mamba architecture’s simplicity and efficiency. To address these issues, we learn local attention on a neighborhood graph without explicit spectral computation, achieving both structural and semantic consistency.

3.3.1. Graph-Based Local Attention

Each center point $c_i$ performs local attention based on its relationships with its KNN $N\left(i\right)$.

$${\alpha }_{ij}={\mathrm{softmax}}_{j\in \mathcal{N}\left(i\right)}\left({\displaystyle \frac{Q_i^{\top }{K}_{ij}}{\sqrt{d_k}}}\right),z_i=\sum _{j\in \mathcal{N}\left(i\right)}{\alpha }_{ij}{V}_{ij}.$$

(5)

Here, ${\alpha }_{ij}$ represents the importance assigned by patch i to its neighbor j, implicitly capturing local structural relations. The aggregated feature $z_i$ encodes contextual information from its neighbors and serves as the refined representation of the center point [48]. The output of multi-head attention is concatenated across heads, followed by a linear transformation, residual connection, and normalization, as shown in Figure 1 and Figure 2 and Algorithm 1.

Figure 1. Overview of proposed MANBO pipeline. (a) Raw point cloud. (b) Grouped patches. (c) LMGA computes head-wise priority scores via lightweight multi-head graph attention. (d) PAOS performs priority-aware global ordering with bidirectional scans. (e) CRM applies composite masking and reconstruction for pre-training. (f,g) Task heads for classification and segmentation.

Figure 2. Illustration of LMGA method. LMGA performs graph-based attention to capture local dependencies, where OrderScale block normalizes and refines both priority scores (${\mathrm{Score}}^{\prime }$) and attention weights (${\mathrm{Attn}}^{\prime }$).

Algorithm 1: Lightweight Multi-Graph Attention (LMGA)

3.3.2. Priority-Aware Scaling

The preceding process is effective in modeling the contextual centrality of each patch, but it involves two inherent ambiguities. (1) The attention distribution can be distorted due to uneven point density, which may lead to instability in the patch priority scores. (2) Sequence consistency can be degraded by attention asymmetry during bidirectional traversal. To alleviate these two issues, we introduce the following priority-aware scaling procedure. First, we compute the priority score $s_i$ from the attention distribution of each center patch i to mitigate the local density bias caused by uneven point distribution [49].

$$H_i=-\sum _{j\in \mathcal{N}\left(i\right)}{\alpha }_{ij}\log ({\alpha }_{ij}+\epsilon ),s_i=1-{\displaystyle \frac{H_i}{\log N_n}}.$$

(6)

Here ${\alpha }_{ij}$ denotes the attention averaged over the M heads, ${\overline{\alpha }}_{ij}={\displaystyle \frac{1}{M}}{\sum }_{m=1}^M{\alpha }_{ij}^{\left(m\right)}$, so that a single distribution per patch enters Equation (6). $H_i$ represents the uncertainty of the attention distribution over the $N_n$ neighbors of patch i, where $N_n=\left|\mathcal{N}\left(i\right)\right|$ denotes the number of KNN neighbors defined in Section 3.1.2. Since $\log N_n$ is the maximum attainable entropy of a distribution over $N_n$ elements, this normalization bounds $s_i$ within $[0,1]$: a more concentrated attention distribution yields a lower $H_i$ and thus a higher priority score. The entropy $H_i$ measures how evenly the attention of patch i is spread over its $N_n$ neighbors. We use $s_i$ as a content-dependent key for ordering, referred to as the attention-derived priority, and do not interpret it as semantic importance: a patch with uniform attention over similar neighbors may still be central to the object. PAOS accounts for this by treating the groups symmetrically. The forward scan ends with the high-score group and the backward scan (Section 3.4) ends with the low-score group, so each group is processed with full sequence context in one direction, and no token is removed. Empirically, the score separates patches by local structure: on the ScanObjectNN test set, the surface variation of the low-score group is 1.8 times that of the high-score group (Figure 3). The grouping is insensitive to the concentration measure: using the Gini concentration instead changes the group assignment of 12% of the patches (rank correlation 0.96). Two properties of LMGA reduce the sensitivity of the priority score to variations in point density. First, each neighborhood contains exactly $N_n=32$ points selected by KNN, so density changes alter the spatial extent of a patch but not the number of attention entries, and the entropy remains bounded in $[0,\log N_n]$. Second, as described in Section 3.4, the priority score is used only through its rank and only to assign each patch to one of three coarse groups, while the order within a group is determined by spatial proximity. Consequently, score perturbations can affect the sequence only for patches whose rank lies near a group boundary. This priority signal is later used in Section 3.4 to define the traversal order.

Figure 3. Patch centers of ScanObjectNN (OBJ-BG) test objects colored by priority group (low/mid/ high, 20%/60%/20% of the patches); gray points are the input point cloud.

Second, to address the directional imbalance between bidirectional traversals, we apply learnable normalization parameters $\gamma$ and $\beta$ in the form of $\widetilde{f_i}=\gamma \odot f_i+\beta$. This normalization, referred to as OrderScale, stabilizes feature distributions between forward and backward traversals, ensuring directional balance in information propagation [16]. Consequently, this process alleviates both local density bias and directional imbalance resulting in stable and consistent token representations.

3.4. Priority-Aware Ordering Strategy (PAOS)

To handle the global sequential structure that Mamba requires, it is important to maintain global flow and order consistency within unstructured point clouds. Although the LMGA strategy is effective in capturing local contextual information, it is limited to local interactions and may fail to sufficiently capture the global ordering. To address this, we propose a PAOS that leverages the computed patch priority $s_i$ to jointly consider spatial proximity and the attention-derived priority.

Given the patch centers $c_i$ and the priorities $s_i$ of Equation (6), the ordering key of patch i is

$${\tilde{s}}_i=(1-\lambda )s_i+\lambda \sum _{j\in {\mathcal{N}}_c\left(i\right)}{w}_{ij}{s}_j,w_{ij}={\displaystyle \frac{\exp \left(-{\parallel c_i-c_j\parallel }^2/{\tau }_i\right)}{{\sum }_{l\in {\mathcal{N}}_c\left(i\right)}\exp \left(-{\parallel c_i-c_l\parallel }^2/{\tau }_i\right)}},$$

(7)

where ${\mathcal{N}}_c\left(i\right)$ is the set of the $K_c=8$ nearest patch centers of $c_i$, ${\tau }_i$ is the mean squared distance from $c_i$ to these neighbors, and $\lambda$ balances the priority of a patch against that of its spatial neighbors. The neighborhood term is an optional smoothing of the ordering key; all results reported in this paper use $\lambda =0$, i.e., ${\tilde{s}}_i=s_i$.

A single ordering is insufficient to fully capture the hierarchical structure of large-scale point clouds; therefore, we perform hierarchical grouping on the ranked ordering keys. Let $\pi$ be the permutation that sorts $\left\{{\tilde{s}}_i\right\}$ in ascending order. We split the sorted sequence into three consecutive blocks whose sizes are fixed proportions of $N_c$, $|G_{\mathrm{low}}|=\lfloor r_{\mathrm{low}}{N}_c\rfloor$, $|G_{\mathrm{mid}}|=\lfloor r_{\mathrm{mid}}{N}_c\rfloor$, and $|G_{\mathrm{high}}|=N_c-|G_{\mathrm{low}}|-|G_{\mathrm{mid}}|$, with $(r_{\mathrm{low}},r_{\mathrm{mid}},r_{\mathrm{high}})=(0.2,0.6,0.2)$ in all experiments. Because the partition is defined on ranks, it does not depend on the scale or shape of the score distribution (Figure 4). Within each group, tokens are arranged by the Hilbert curve order of their center coordinates (transposed Hilbert order for the backward scan), so that local spatial continuity inside a group is independent of the priority scores; the scores decide only the coarse order of the three blocks. The forward sequence is the concatenation $G_{\mathrm{low}}\to G_{\mathrm{mid}}\to G_{\mathrm{high}}$ and the backward sequence is $G_{\mathrm{high}}\to G_{\mathrm{mid}}\to G_{\mathrm{low}}$; the two sequences are concatenated and each is modulated by its own OrderScale parameters before the Mamba encoder. Ties in ${\tilde{s}}_i$ are broken by the sorting implementation, which in practice does not occur for floating-point entropies. The proportions were fixed in all experiments and were not tuned.

Figure 4. Distribution of the priority scores $s_i$ over the ScanObjectNN (OBJ-BG) test set (mean 0.118, skewness 1.51). The rank-based split of Section 3.4 is independent of this shape.

No gradient passes through the sort, and no differentiable relaxation is used. LMGA is trained through its refined tokens $z_i$, which form the content of the sequence (through the reconstruction loss in pre-training and the classification loss in fine-tuning); the traversal order is derived from the attention that is itself learned, and we therefore refer to it as an attention-derived ordering. In other words, the proposed ordering preserves the priority-based flow globally while maintaining geometric continuity locally. This section is illustrated in Figure 1 and Figure 5.

Figure 5. (a) Learning each token’s priority score by analyzing attention distribution. (b) Using learned priority scores, all tokens are globally reordered into left-to-right traversal sequence, capturing progressive spatial relationships among point tokens.

3.5. Composite Ratio Masking (CRM)

Building upon the pre-training frameworks of recent point cloud methods, Point-MAE [9] and Point-M2AE [10], this study explores ways of enhancing the model’s representation learning capability through self-supervised pre-training using the MAE framework. Existing autoencoder-based self-supervised learning methods [8,50,51] tokenize point clouds and perform pre-training by masking a large portion $(60\%\uparrow )$ of the tokens. A common observation across these studies is that, regardless of differences in masking strategies, autoencoder architectures, or task heads, most adopt a high masking ratio. This trend is consistent with the intuition of point cloud reconstruction, where high masking ratios encourage the model to infer missing geometry. Thus, a high masking ratio is intended to encourage the model to learn more complex and semantically meaningful representations during pre-training. However, when the masking ratio is low, the model can directly observe most of the input points, which reduces the difficulty of reconstruction and consequently leads to simple memorization rather than meaningful learning, degrading generalization capability. Therefore, while the model can reconstruct fine-grained local details, it struggles to infer the masked regions or learn global contextual relationships. To mitigate this trade-off, we propose the CRM strategy, which incorporates composite learning patterns instead of relying on a single masking ratio within the MAE framework. The key idea is to enable the model to learn according to the reconstruction difficulty from point clouds masked with different ratios, allowing it to autonomously form the most reliable reconstruction pattern.

Specifically, given the serialized sequence $X={\left\{x_i\right\}}_{i=1}^{N_c}$ as input, a traversal direction is randomly selected, and three masking ratios $(m_1,m_2,m_3)$ are applied according to the chosen direction. Each masked token is removed from the sequence while its original positional information is recorded, and the three masked versions share the same encoder–decoder structure. Subsequently, only the remaining visible tokens are fed into the encoder to compute feature representations, while the decoder restores the complete point cloud by reinserting learnable tokens into their original positions based on the recorded positional information. The reconstruction error of each masked patch is computed using the Chamfer distance, consistent with previous studies. Finally, the loss ${\mathcal{L}}_{m_i}$ is computed from the reconstruction results of each masking ratio, and the final loss is obtained by applying the predefined weights for each ratio as follows:

$${\mathcal{L}}_{\mathrm{CRM}}={\displaystyle \sum _{i=1}^3}{\beta }_i{\mathcal{L}}_{m_i},\mathrm{where}{\beta }_i={\displaystyle \frac{m_i}{{\sum }_j{m}_j}}.$$

(8)

Here, ${\beta }_i$ serves as a weight proportional to the difficulty of each masking level. A higher masking ratio ($m_i\uparrow$) increases the reconstruction difficulty, thereby assigning a greater contribution to the overall loss. This approach enhances overall training efficiency and representation learning performance by reflecting diverse learning weights according to reconstruction difficulty. The weights are fixed a priori as the normalized masking ratios and were not tuned. Because the Chamfer loss of each branch is averaged over its masked patches, the three unweighted losses are of similar magnitude throughout pre-training (Section 4.3.3), so Equation (8) acts as a fixed 3:2:1 emphasis on the branch with the least visible context rather than compounding an already larger loss. The visual effect is shown in Figure 1.

4. Experiments and Analysis

In this section, we first describe the pre-training setup of the proposed model using the ShapeNet [52] training dataset. Subsequently, the pre-trained model is evaluated on various downstream tasks, including object classification, few-shot learning, and part segmentation. In addition, an ablation study is conducted to analyze the effectiveness of the proposed MANBO model.

4.1. Pre-Training Setup

We follow the experimental setup of PointMamba [16] and pre-train our model on the ShapeNet [52] dataset. The quality of the learned 3D representations is evaluated by fine-tuning on downstream datasets such as ModelNet40 [53] and ScanObjectNN [54], measuring classification accuracy as the evaluation metric. Data augmentation was configured identically to previous studies for fair comparison. During pre-training, only rotation transformations were applied; during fine-tuning, the same rotation is applied on ScanObjectNN, whereas scale and translation augmentations are used on ModelNet40. Following PointMamba, we use $N=2048$ points, $G=128$ patches of $k=32$ points on ScanObjectNN and $N=1024$, $G=64$, $k=32$ on ModelNet40 and for pre-training, a token dimension of 384, and 12 Mamba blocks. Pre-training runs for 300 epochs with masking ratios $(0.6,0.4,0.2)$ and reconstructs the points of the masked patches with the L2 Chamfer distance. LMGA uses $M=6$ heads of dimension 64, and the group proportions $(0.2,0.6,0.2)$ with $\lambda =0$ and $K_c=8$ were fixed once for all benchmarks. Optimizer, schedule, and batch size follow PointMamba (AdamW with a cosine schedule and 10 warm-up epochs; batch size 128 for pre-training and 32 for fine-tuning), and the pre-training decoder has four Mamba blocks. The classification accuracies of our models in Table 1, Table 2, Table 3 and Table 4 are means over five fine-tuning runs on OBJ-BG and over three runs on the other benchmarks.

Table 1. Object classification on ScanObjectNN [54]. Accuracy (%) is reported. ^† indicates that this uses simple rotational augmentation. ‘*’ denotes reproduced results.

Methods	Backbone	Param. (M)	FLOPs (G)	OBJ-BG	OBJ-ONLY	PB-T50-RS	ModelNet40
Training without pre-training
PointNet [6]	-	3.5	0.5	73.3	79.2	68.0	89.2
PointNet++ [6]	-	1.5	1.7	82.3	84.3	77.9	90.7
DGCNN [21]	-	1.8	2.4	82.8	86.2	78.1	92.9
PointCNN [55]	-	0.6	0.9	86.1	85.5	78.5	-
PointMLP [56]	-	13.2	31.4	-	-	85.4	-
ADS [57]	-	-	-	-	-	87.5	-
Transformer [8]	Transformer	22.1	4.8	79.86	80.55	77.24	-
Point-MAE [9]	Transformer	22.1	4.8	86.75	86.92	80.78	92.3
Training from pretrained
MaskPoint [58]	Transformer	22.1	4.8	89.30	88.10	84.30	92.6
Point-MAE [9]	Transformer	22.1	4.8	90.02	88.29	85.18	93.2
Point-M2AE [10]	Transformer	15.3	3.6	91.22	88.81	86.43	93.4
Transformer-OcCo [8]	Transformer	-	-	84.85	85.54	78.79	-
Point-BERT [8]	Transformer	22.1	4.8	87.43	88.12	83.07	92.7
Point-MAE + IDPT [59]	Transformer	1.7	7.2	91.22	90.22	84.94	-
Point-MAE † [9]	Transformer	22.1	4.8	92.77	91.22	89.04	-
PCM [17]	Mamba	12.3	3.6	-	-	86.9	-
SI-Mamba * † [18]	Mamba	12.3	3.6	93.80	89.84	87.64	93.1
PointMamba * † [16]	Mamba	12.3	3.1	94.14	91.39	88.16	92.4
Ours †	Mamba	12.4	3.3	94.76	92.03	88.81	93.2

Table 2. Component-wise ablation. Each row represents an independent configuration built on the baseline (PointMamba) backbone. Accuracy (%) is reported as mean ± standard deviation over five fine-tuning runs on OBJ-BG and three runs on the other benchmarks.

Configuration	OBJ-BG	OBJ-ONLY	PB-T50-RS	ModelNet40
Baseline	94.14 ± 0.12	91.39 ± 0.17	88.16 ± 0.13	92.4 ± 0.1
+ LMGA only	94.25 ± 0.15	91.51 ± 0.10	88.31 ± 0.10	92.6 ± 0.1
+ LMGA + PAOS	94.38 ± 0.26	91.69 ± 0.09	88.52 ± 0.12	92.7 ± 0.1
+ CRM only	94.25 ± 0.15	91.45 ± 0.10	88.35 ± 0.11	92.5 ± 0.1
+ LMGA + PAOS + CRM (full)	94.76 ± 0.09	92.03 ± 0.19	88.81 ± 0.00	93.2 ± 0.0

Table 3. Object classification on ScanObjectNN. Accuracy (%) is reported as mean ± standard deviation over five fine-tuning runs.

Methods	Param. (M)	Heads	OBJ-BG
Training from pretrained
Ours (LMGA)	12.4	3	93.97 ± 0.12
Ours (LMGA)	12.4	4	93.11 ± 0.13
Ours (LMGA)	12.4	6	94.76 ± 0.09
Ours (LMGA)	12.4	8	92.08 ± 0.14

Table 4. Mask construction for pre-training.

Mask Construction	OBJ-BG	PB-T50-RS
$\left[0.6\right]$	94.38	88.52
$[0.5,0.5]$	94.31	88.35
$[0.6,0.4]$	94.28	88.11
$[0.7,0.3]$	94.28	87.56
$[0.8,0.2]$	94.33	88.16
$[0.9,0.1]$	93.8	88.20
$[0.6,0.4,0.2]$	94.76	88.81
$[0.7,0.5,0.3]$	94.14	88.20
$[0.8,0.5,0.2]$	94.08	88.26
$[0.9,0.5,0.1]$	94.32	88.56
$[0.8,0.6,0.4,0.2]$	94.11	87.07
$[0.7,0.5,0.3,0.1]$	94.08	87.19
$[0.9,0.7,0.5,0.3]$	93.77	86.93
$[0.7,0.6,0.5,0.4]$	94.11	86.71

4.2. Downstream Tasks

4.2.1. Real-World Object Classification

To evaluate the performance of the proposed method on real-world data, we conducted experiments on the ScanObjectNN [54] dataset following the same evaluation protocol as previous studies. This dataset consists of approximately 15,000 objects across 15 categories and provides realistic challenges due to its inclusion of cluttered backgrounds, closely resembling real-world environments. As shown in Table 1, the proposed method improves classification accuracy in experiments with gradually increasing complexity. This demonstrates that the proposed method possesses a robust generalization capability to effectively recognize and distinguish objects even in complex real-world environments.

4.2.2. Clean Object Classification

To evaluate the performance of the proposed method, we followed the same protocol as previous studies and conducted experiments using the ModelNet40 [53] dataset. This dataset consists of 12,311 clean 3D CAD samples across 40 object categories, and as shown in Table 1, the proposed method consistently outperforms Mamba-based approaches under the same protocol and reaches accuracy comparable to Transformer-based approaches with about half of their parameters. This indicates that the proposed approach achieves stable and reliable performance improvements even when applied to the Point-Mamba network.

4.2.3. Few-Shot Learning

We additionally conducted few-shot learning experiments on the ModelNet40 [53] dataset following the experimental protocol of previous studies [8,16]. For each setting, we ran 10 independent trials, and we report the results as mean accuracy and standard deviation. As shown in Table 5, the proposed method demonstrates stable performance even in a highly competitive benchmark where performance differences are minimal. In particular, it achieves comparable or superior performance to both Mamba and Transformer-based methods.

Table 5. Few-shot Learning on ModelNet40 [53]. Overall accuracy (%) ± the standard deviation (%) without voting is reported.

Methods	5-Way		10-Way
	10-Shot	20-Shot	10-Shot	20-Shot
Training without pre-training
DGCNN [21]	91.8 ± 3.7	93.4 ± 3.2	86.3 ± 6.2	90.9 ± 5.1
DGCNN-CrossPoint [60]	92.5 ± 3.0	94.9 ± 2.1	83.6 ± 5.3	87.9 ± 4.2
PointNet-CrossPoint [60]	90.9 ± 1.9	93.5 ± 4.4	84.6 ± 4.7	90.2 ± 2.2
Training with pre-training
Point-MAE [9]	96.3 ± 2.5	97.8 ± 1.8	92.6 ± 4.1	95.0 ± 3.0
Point-M2AE [10]	96.8 ± 1.8	98.3 ± 1.4	92.3 ± 4.5	95.0 ± 3.0
Point-BERT [8]	94.6 ± 3.1	96.3 ± 2.7	91.0 ± 5.4	92.7 ± 5.1
Transformer [8]	87.8 ± 5.2	93.3 ± 4.3	84.6 ± 5.5	89.4 ± 6.3
Transformer-OcCo [8]	94.0 ± 3.6	95.9 ± 2.3	89.4 ± 5.1	92.4 ± 4.6
SI-Mamba [18]	96.4 ± 2.7	98.5 ± 1.5	92.0 ± 5.1	95.1 ± 3.6
PointMamba [16]	95.9 ± 2.1	97.3 ± 1.9	91.6 ± 5.3	94.5 ± 3.5
Ours	96.8 ± 2.1	98.8 ± 0.8	92.3 ± 4.1	95.2 ± 3.5

4.2.4. Part Segmentation

Part segmentation on the ShapeNetPart [61] dataset is a challenging point-wise fine-grained task that requires predicting precise labels for each individual point. As shown in Table 6, the proposed method consistently improves performance over existing Mamba-based models. It also maintains similar accuracy to state-of-the-art Transformer-based architectures such as Point-GPT-S [50] and ACT [62] at low computational cost. These results demonstrate that the Mamba architecture has strong potential for point cloud analysis.

Table 6. Part segmentation on ShapeNetPart [61]. The mIoU for all instances (Inst.) is reported.

Methods	Backbone	FLOPs (G)	mIoU
Training without pre-training
PointNet [6]	-	-	83.7
PointNet++ [7]	-	-	85.1
DGCNN [21]	-	-	85.2
APES [63]	-	-	85.8
Point-MAE [9]	Transformer	15.5	85.7
Training with pre-training
Point-MAE [9]	Transformer	15.5	86.1
Point-M2AE [10]	Transformer	15.5	86.5
Point-BERT [8]	Transformer	15.5	85.6
Transformer [8]	Transformer	15.5	85.1
ACT [62]	Transformer	-	86.2
Point-GPT-S [50]	Transformer	-	86.2
PointMamba [16]	Mamba	14.3	86.0
SI-Mamba [18]	Mamba	14.3	86.1
Ours	Mamba	14.5	86.3

4.3. Ablation Studies

In this section, we provide comprehensive ablation studies to evaluate the contribution of each proposed component in our model. We first isolate the individual and combined contributions of LMGA, PAOS, and CRM, and then analyze the design choices within each module: the effect of LMGA and PAOS on spatial reasoning, and the impact of CRM on representation learning.

4.3.1. Component-Wise Analysis

Before examining the design choices within each module, we first isolate the contribution of each proposed component. Table 2 reports independent configurations built on the PointMamba backbone under a matched fine-tuning protocol. Applying LMGA alone improves over the baseline (94.25 vs. 94.14 on OBJ-BG), at a cost of 0.08 M parameters and 0.22 G FLOPs (Section 4.4), and adding PAOS yields a further gain (94.38), indicating that both the graph-based relational features and the priority-aware ordering contribute even under single-ratio masking. Applying CRM directly to the baseline also improves performance (94.25), but remains well below the full model. The full configuration achieves the best results on all benchmarks (94.76, 92.03, 88.81, and 93.2, respectively), exceeding the sum of the individual gains: on OBJ-BG, the architectural components and CRM contribute +0.24 and +0.11 over the baseline respectively, while their combination yields +0.62. These results indicate that priority-guided serialization and multi-ratio masked pre-training are complementary rather than redundant. To interpret the differences in Table 2, we additionally fine-tuned the full model with three different random seeds and obtained $94.72\pm 0.10$ on OBJ-BG (Appendix A); the gain of the full model over the baseline ($+0.62$) is about six times this deviation, and each component improves over the baseline on all four benchmarks. Note that each row in Table 2 is an independent configuration rather than a cumulative one, and the single-ratio entry $\left[0.6\right]$ in Table 4 corresponds to the “+ LMGA + PAOS” setting.

4.3.2. Analysis of Graph and Ordering

We jointly analyzed the impact of the number of heads used in the LMGA and PAOS strategies and the effect of different priority ordering schemes on performance. First, we analyzed how the number of attention heads in the GAT layer used in the LMGA strategy affects the classification performance on the ScanObjectNN dataset. As shown in Figure 6 (Left) and Table 3, the classification accuracy is highest when the number of heads is set to six, achieving the best performance (94.76%). Table 3 reports means over five fine-tuning runs; the run-to-run deviation measured over three seeds (0.10 points, Appendix A) is an order of magnitude smaller than the differences between head counts, so the trend reflects the head count itself. Second, as shown in Figure 6 (Right) and Figure 7, the comparison of priority ordering schemes reveals that the proposed ordering strategy consistently achieves higher performance than both spatial-only (Hilbert) and bi-directional traversal methods [44,64]. To compare PAOS with other serialization strategies under identical conditions, we additionally keep the fine-tuned weights fixed and replace only the ordering used at inference (Appendix B): the spectral order of SI-Mamba and the Hilbert order lower the OBJ-BG accuracy by 0.9 and 0.6 points, and priority-only and random orders by about 1.7 points. The priority is thus effective in combination with the spatial order, as in the proposed priority-aware ordering, which also avoids the eigendecomposition required by spectral ordering. Since the ordering is replaced only at inference, this comparison is not a training-time ablation.

Figure 6. Analysis of the number of heads in LMGA (Left) and different ordering strategies (Right).

Figure 7. Visualization of part segmentation results of our PAOS method on the ShapeNetPart dataset.

4.3.3. Analysis of Masking Strategy

In another experiment, we analyzed the effect of the proposed CRM strategy on the model’s feature learning. We evaluate how the input masking ratio used during the self-supervised pre-training stage affects the performance on the downstream ObjectNN task. We adopt the simplest scheme, a single masking ratio of 0.6, as our baseline and compare it with the CRM configurations presented in Table 4. Our hypothesis is that, compared to a single masking ratio, a more complex Composite-ratio configuration encourages the model to learn features at multiple scales, thereby improving performance. Table 4 shows the performance variation as the masking configuration is extended to 2, 3, and 4 ratios. As can be seen in Table 4, configuring the masks with three ratios, such as [0.6,0.4,0.2], achieves the highest performance. This is because, with a single masking ratio, the model is exposed only to reconstruction tasks of limited difficulty, preventing its representations from becoming sufficiently expressive. Conversely, this can be interpreted as the completion signal being diluted due to interference among different masking patterns when too many masking ratios are used.

First, Figure 8a,b visualize the feature distributions learned on the ModelNet40 dataset using t-SNE [65] to validate the effect of mask ratio diversity. While the model trained with a single masking ratio shows loose feature embeddings and ambiguously overlapping class boundaries, the model trained with CRM exhibits denser and more clearly separated clusters. Furthermore, Figure 8c compares the performance of the pre-trained model when fine-tuned on four downstream tasks, with and without CRM. The model trained with CRM consistently outperforms the model without it. This suggests that the proposed CRM strategy effectively guides the model to capture fine-grained semantic structures within the point cloud. To avoid relying on the visual impression of t-SNE, which depends on parameters such as perplexity, we additionally quantify cluster quality directly on the features of the pre-trained encoder; CRM improves the Silhouette score, the Davies–Bouldin index, and the inter-/intra-class distance ratio (Appendix D), consistent with Figure 8b. Because CRM processes three masked views of each point cloud, we also compare it with a compute-matched control that uses three independently sampled masks at the same ratio, $[0.6,0.6,0.6]$, with the same number of encoder–decoder evaluations. CRM remains 0.64 points higher on OBJ-BG, about six times the run-to-run deviation (Appendix A), so the gain comes from the diversity of masking ratios rather than from the amount of supervision. Figure 9 plots the unweighted reconstruction loss of each branch during pre-training: all three losses decrease throughout training, none plateaus early, and they remain within about 10% of each other, so the high-ratio branch is not left behind and the weights of Equation (8) act on terms of the same magnitude.

Figure 8. Visualization of learned feature embeddings using (a) simple masking and (b) proposed CRM, and (c) comparison of fine-tuning performance on downstream tasks.

Figure 9. Unweighted Chamfer loss of the three CRM branches (masking ratios 0.6, 0.4, 0.2) during pre-training, epochs 10–300 (the loss drops from about 450 to 4 within the first ten epochs).

4.4. Efficiency Analysis on FLOPs, Runtime, and Memory Usage

In this section, we present a comprehensive analysis of the computational efficiency, runtime, and memory usage of our LMGA approach. The focus of this experiment is to evaluate the overhead introduced by the LMGA strategy compared to the backbone model, PointMamba. LMGA introduces a single graph attention layer over the G patch tokens produced by the patch tokenizer (Section 3.2), before the Mamba encoder. For each of the G centers it attends over the k points of its own patch, so its cost is $\mathcal{O}(G·k·C_h)$ per head. In our setting ($G=128$, $k=32$, $M=6$, $C_h=64$) this amounts to approximately 0.22 G FLOPs and 0.08 M parameters, compared with approximately 3.1 G FLOPs and 12.3 M parameters for the Mamba backbone; the complete model therefore has 12.4 M parameters and 3.3 G FLOPs (Table 1), i.e., 0.6% more parameters and 7% more FLOPs than PointMamba. MANBO constructs no additional graph, since LMGA attends over the FPS + KNN neighborhoods that the patch tokenizer already computes; the ordering adds no module, because the priority is obtained from the attention weights that LMGA already produces and consists of a single sort of the G patch scores, independent of the number of input points; and CRM is used in pre-training only, so it adds no cost at fine-tuning or inference. The additional computation of CRM is confined to pre-training, where three masked views of each point cloud are processed instead of one. The overhead introduced by this operation is negligible compared to the total computational cost of the backbone model, for the following reasons: (1) Since it uses only a single-shot Graph Attention layer, the number of additional parameters and the computational depth are very small compared to the Mamba encoder. (2) Instead of operating on all points (2048), it processes only the G tokens (128) that have been pre-aggregated at the grouping stage and computes attention once over this reduced token set, resulting in a complexity of $\mathcal{O}(G·k)$. (3) It operates directly on the per-point and per-patch features produced by the patch tokenizer and adds only the linear query, key, and value projections. As no additional buffers or intermediate feature maps are stored in the implementation, the increase in GPU memory usage is minimal.

4.4.1. Runtime

Figure 10 shows the overall runtime of the model. The total runtime when running only the backbone (blue line) and when using the full model with the additional LMGA module (orange line) is almost identical. This indicates that the computation of LMGA occupies only a very small portion of the overall pipeline and therefore does not become a temporal bottleneck.

Figure 10. Runtime over token length, used token lengths from $2^7$ to $2^{12}$.

4.4.2. Memory Usage

Figure 11 illustrates the memory usage of the LMGA module itself. While the memory requirement of the backbone (blue line) increases sharply as the token length grows, the LMGA module (orange line) remains almost flat and close to zero even when the token length reaches 4096. This is a direct consequence of the efficient tensor reuse strategy described above.

Figure 11. Memory Usage over token length, used token lengths from $2^7$ to $2^{12}$.

4.4.3. FLOPs

Figure 12 presents the computational cost (FLOPs) of the LMGA module itself. In contrast to the backbone (blue line), whose FLOPs increase steeply, the FLOPs of the LMGA module (orange line) remain extremely low and nearly constant across the entire token range. This visually demonstrates the low computational complexity of $\mathcal{O}(G·k)$.

Figure 12. FLOPs over token length, used token lengths from $2^7$ to $2^{12}$.

5. Limitation and Conclusions

In this paper, we propose strategies to enhance the Mamba network for point cloud data processing. The integration of the lightweight graph construction, priority-based spatial traversal, and composite masking enabled sequence-based representation learning while preserving spatial structure, achieving consistent gains over Mamba-based methods on object-level classification, few-shot learning, and part segmentation, at a lower parameter count than Transformer-based methods. A limitation of our method is its reliance on hyperparameters such as head count and masking ratio. Although per-dataset tuning can improve performance, it can also degrade generalization, so careful adjustment is required to preserve robustness.