MogaDepth: Multi-Order Feature Hierarchy Fusion for Lightweight Monocular Depth Estimation

TL;DR

MogaDepth is a lightweight method for estimating depth from a single image, improving accuracy and efficiency by better capturing object structures and spatial relationships.

Contribution

The paper introduces MogaDepth with a novel CMOGA module and MambaSync unit to enhance mid-level feature interactions for depth estimation.

Findings

MogaDepth improves key error metrics on KITTI while maintaining model size.

It outperforms existing methods on Make3D, showing robustness to domain shifts and low-texture regions.

MogaDepth runs 13% faster on edge devices without performance loss.

Abstract

Monocular depth estimation is a fundamental task with broad applications in autonomous driving and augmented reality. While recent lightweight methods achieve impressive performance, they often neglect the interaction of mid-order semantic features, which are crucial for capturing object structures and spatial relationships that directly impact depth accuracy. To address this limitation, we propose MogaDepth, a lightweight yet expressive architecture. It introduces a novel Continuous Multi-Order Gated Aggregation (CMOGA) module that explicitly enhances mid-level feature representations through multi-order receptive fields. In addition, we present MambaSync, a global–local interaction unit that enables efficient feature communication across different contexts. Extensive experiments demonstrate that MogaDepth achieves highly competitive or superior performance on KITTI, improving key error metrics while maintaining comparable model size. On the Make3D benchmark, it consistently outperforms existing methods, showing strong robustness to domain shifts and challenging scenarios such as low-texture regions. Moreover, MogaDepth achieves an improved trade-off between accuracy and efficiency, running up to 13% faster on edge devices without compromising performance. These results establish MogaDepth as an effective and efficient solution for real-world monocular depth estimation.

Figures

Full text

1. Introduction

Depth estimation plays a vital role in a wide range of applications, including autonomous driving, 3D reconstruction [1], augmented reality, robotics, and medical imaging. Accurate depth perception enables the understanding of spatial scene structures, object positioning, and metric distances, which are foundational for tasks such as semantic segmentation, autonomous navigation, robotic surgery assistance, and human pose estimation.

Traditional depth sensing systems, such as radars, LiDARs, or stereo cameras, often produce sparse depth representations and are constrained by cost, power consumption, and hardware complexity. Depth cameras using stereo disparity, structured light, or time-of-flight methods provide denser outputs, but they suffer from photometric sensitivity, limited range, and motion blur. These limitations hinder performance in dynamic environments and long-range scenes, prompting the development of monocular depth estimation methods.

Monocular depth estimation based on supervised learning, particularly when utilizing convolutional neural networks (CNNs), attains superior results when trained with high-quality annotated depth data [2,3,4]. However, the scarcity and high cost of dense annotations present practical implementation challenges. Consequently, self-supervised methods have emerged as a promising alternative by exploiting geometric constraints from stereo image pairs or monocular video sequences [5,6,7,8].

Self-supervised monocular depth estimation can be broadly categorized into two primary paradigms: stereo-based approaches [5] and video-based frameworks [6,8,9]. Stereo-based techniques estimate depth by analyzing geometric disparities between synchronized rectified image pairs. While these methods eliminate the need for explicit camera motion estimation, their dependency on dual-camera systems imposes stringent calibration requirements and synchronization constraints, thereby restricting their scalability in real-world deployments. By contrast, video-based methodologies leverage sequential frames captured by a monocular camera in motion, necessitating integration with pose estimation networks to infer camera motion trajectories [6,9,10,11]. Despite this added complexity, monocular video systems demonstrate enhanced deployment flexibility as they circumvent hardware limitations associated with stereo configurations, rendering them particularly advantageous for edge computing applications on resource-constrained mobile platforms or embedded systems.

Recent progress in video-based paradigms has addressed key challenges through multi-faceted optimization strategies: generative adversarial networks (GANs) [12] mitigate occlusion artifacts and dynamic scene complexities, semantic supervision modules [13,14] enhance depth consistency, and advanced loss formulations [6] improve prediction accuracy. Concurrently, hybrid architectures integrating convolutional neural networks (CNNs) with vision transformers (ViTs) [15] have attracted significant interest due to their complementary strengths—CNNs excel at hierarchical feature aggregation through spatially-localized receptive fields, while ViTs capture global dependencies via self-attention mechanisms. However, existing hybrid models still face unresolved bottlenecks that impede their practical deployment and performance.

Specifically, three core limitations persist in current state-of-the-art methods. First, in terms of computational complexity, ViTs exhibit quadratic computational complexity relative to input resolution, making them infeasible for high-resolution depth estimation in low-power, resource-constrained environments. Second, regarding feature representation, most lightweight depth estimation models (e.g., R-MSFM [11,16], Lite-Mono [10]) focus predominantly on low-order cues (e.g., edges and textures) or high-order semantics (e.g., global context), lacking explicit mechanisms to model mid-order features (e.g., object parts, contours, and intermediate spatial structures). This oversight leads to oversmoothed depth maps and compromised structural fidelity. Third, in terms of deployment adaptability, a critical trade-off exists between accuracy, computational efficiency, and deployment flexibility—existing lightweight models often sacrifice depth estimation accuracy to reduce complexity, failing to meet the requirements of real-time embedded applications.

To address these limitations, we propose a lightweight and efficient depth estimation model with a hybrid CNN and Mamba architecture, which constitutes an innovative amalgamation for enhancing the accuracy of depth prediction while maintaining computational efficiency. Specifically, inspired by EfficientViM [17], we design the MambaSync module to replace the computationally expensive self-attention mechanism with a structured state-space model (SSM). This SSM achieves linear computational complexity in both time and space, significantly reducing memory usage and enabling scalability to high-resolution feature maps. Unlike conventional attention mechanisms that process all token pairs indiscriminately, Mamba leverages a parameter-efficient and sequence-aware formulation that captures long-range dependencies with greater efficiency, while supporting parallel sequence processing and exhibiting strong inductive biases for spatial and temporal continuity—traits particularly advantageous for dense prediction tasks where both global coherence and local detail are critical. Complementing this, the CMOGA module enhances spatial and semantic representation through hierarchical fusion of low-, mid-, and high-order features, explicitly addressing the gap in mid-order feature modeling. Together, these two components enable MogaDepth to accomplish accurate and consistent depth predictions while maintaining computational efficiency suitable for real-time and resource-constrained applications.

Our main contributions can be summarized as follows:

• We propose a lightweight, end-to-end self-supervised depth estimation architecture that achieves strong performance while minimizing parameters and floating-point operations (FLOPs).
• Our model achieves highly competitive results on the KITTI benchmark [18] and generalizes well to the Make3D dataset [19], demonstrating strong cross-domain robustness.
• We validate MogaDepth’s efficiency and real-time performance on NVIDIA RTX 3090 and Jetson Xavier, demonstrating its practical deployability.

2. Related Work

Monocular depth estimation from a single image is inherently under-constrained due to perspective projection. Deep learning methods address this challenge by learning hierarchical multi-scale features, and current approaches can be broadly categorized into supervised and self-supervised paradigms. This section reviews relevant advances in these areas, with a specific focus on self-supervised methods (organized by their technical paradigms) and lightweight model designs, while analyzing existing limitations to motivate the contributions of this work.

2.1. Supervised Depth Estimation

Supervised monocular depth estimation methods train CNN-based models using paired RGB-depth data, which provides direct supervision for depth prediction. Early works [3] pioneered multi-scale prediction architectures to capture spatial details at different resolutions. Subsequent improvements integrated complementary cues (e.g., semantic segmentation, motion information) and advanced fusion strategies [20,21,22,23] to enhance depth consistency and accuracy. While supervised methods can achieve high performance when sufficient annotated data is available, their practical applicability is severely constrained by the scarcity and high annotation cost of large-scale dense depth datasets. This fundamental limitation has driven the shift toward self-supervised depth estimation, which leverages intrinsic geometric constraints of visual data to avoid reliance on manual annotations.

2.2. Self-Supervised Monocular Depth Estimation

Self-supervised methods eliminate the need for annotated depth data by exploiting photometric consistency across multiple views (stereo pairs or video sequences). Based on the source of visual cues, they can be divided into two primary paradigms that align with the classification in the Introduction: stereo-based approaches and video-based frameworks.

2.2.1. Stereo-Based Approaches

Stereo-based self-supervised methods estimate depth by analyzing geometric disparities between synchronized and rectified left-right image pairs. Godard et al. [24] laid the foundation for this paradigm by introducing left-right consistency constraints to regularize depth prediction, effectively mitigating ambiguous depth estimates. These methods offer the advantage of avoiding explicit camera motion estimation, simplifying the model pipeline. However, their inherent dependency on dual-camera systems imposes stringent requirements on hardware calibration and temporal synchronization. Such constraints significantly limit their scalability in real-world deployments (e.g., on resource-constrained monocular devices), restricting their applicability in broader edge computing scenarios.

2.2.2. Video-Based Frameworks

Video-based self-supervised methods leverage sequential frames captured by a moving monocular camera, requiring joint optimization of depth estimation and camera pose prediction networks to infer 3D scene structure. Monodepth2 [6] represents a landmark work in this area, introducing multi-scale loss, auto-masking, and minimum reprojection error strategies to address key challenges such as static scene ambiguity and occlusion artifacts. Zhou et al. [8] further advanced the field by proposing a dual-branch encoder-decoder architecture for end-to-end joint depth and pose estimation, enabling unsupervised learning purely through photometric loss. Subsequent works have focused on refining network components and fusion strategies to enhance robustness and accuracy. For example, SPIdepth [25] emphasizes the design of more robust pose estimation networks to improve cross-scene generalization, while ProDepth [26] introduces probabilistic multi-frame fusion techniques to handle dynamic scenes more effectively. Despite these advances, video-based frameworks still face critical limitations: existing models either rely on computationally expensive architectures (e.g., large CNNs or ViTs) that hinder real-time deployment, or sacrifice depth accuracy when pursuing lightweight designs—especially in scenarios requiring fine-grained structural detail.

2.3. Lightweight Depth Estimation Models

With the growing demand for deploying depth estimation models on resource-constrained devices (e.g., mobile phones, embedded systems), lightweight depth estimation has emerged as a key research focus. The core goal of this area is to balance high depth estimation accuracy with reduced model size and computational cost. Current lightweight design strategies can be broadly categorized into three types: network pruning [27], knowledge distillation [28], and efficient architectural design [29,30,31]. Network pruning removes redundant connections and neurons to compress model size, while quantization reduces memory usage by adopting lower-bit representations. Knowledge distillation transfers learned features from large, high-performance “teacher” models to compact “student” models, preserving performance with reduced complexity. Among these strategies, efficient architectural design is the most actively explored direction, which leverages techniques such as depthwise separable convolutions, residual connections, and lightweight attention mechanisms, often combined with multi-scale feature fusion to retain spatial detail and semantic consistency.

Representative lightweight frameworks include R-MSFM [12,16], which employs fixed-resolution multi-layer depth optimization and multi-scale feature fusion to improve accuracy. However, its fixed-resolution design limits multi-scale perception capabilities and fails to fully exploit mid-order features (e.g., object contours and part structures), leading to suboptimal structural fidelity in depth predictions. Hybrid CNN-Transformer architectures have also been explored as alternatives to pure CNN-based lightweight models. For instance, Lite-Mono [10] combines the strengths of CNNs in local feature extraction with the global context modeling capability of Transformers. While modules such as CDC (continuous dilated convolution) and LGFI (lightweight global feature interaction) enhance multi-scale feature fusion, these designs inherently focus on integrating low-order cues (edges, textures) or high-order semantics (global context) without explicit mechanisms to model mid-order feature interactions. This oversight results in oversmoothed depth maps and compromised structural detail—gaps that motivate the design of our proposed model.

To address the aforementioned limitations in mid-order feature modeling and computational efficiency, this work proposes the Continuous Multi-Order Gated Aggregation (CMOGA) module, which explicitly captures interactions between low-, mid-, and high-order features to bridge local detail and global context. Complementing this, the MambaSync module leverages a structured state-space model (SSM) to achieve linear computational complexity in long-range dependency modeling, avoiding the quadratic complexity of traditional Transformers. The synergistic integration of these two modules enables our MogaDepth model to achieve both lightweight deployment and high structural fidelity in depth predictions.

3. Methodology

Although Lite-Mono [10] provides a strong lightweight baseline by combining CNNs and Transformers, its encoder still faces challenges in preserving fine-grained details and achieving efficient global modeling. To address these issues, we mainly focus on improving the encoder. Specifically, we replace the CDC module with the proposed CMOGA, which enhances mid-order and boundary-aware representations, and substitute the LGFI module with MambaSync, a scalable state-space model that efficiently captures long-range dependencies. These modifications build on the strengths of Lite-Mono while further improving detail preservation and computational efficiency.

The overall architecture of the proposed MogaDepth is presented in Figure 1.

3.1. MogaDepth Encoder

As shown in the blue box of Figure 1, the proposed MogaDepth Encoder adopts a four-level multi-scale feature aggregation architecture, which is theoretically motivated by the inherent demand of dense monocular depth estimation for both fine-grained spatial details and high-level semantic context. This architecture realizes efficient representation learning through progressive downsampling and cross-stage feature fusion, striking a balance between feature richness and computational efficiency for resource-constrained scenarios. An input RGB image with dimensions $[eqn]$ first passes through an initial convolutional backbone composed of two groups of $[eqn]$ convolutional layers (stride = 1). This backbone is designed to suppress high-frequency noise while extracting primary edge and texture features, generating the first-stage feature map with dimensions $[eqn]$ . For the second stage, to mitigate spatial information loss caused by direct downsampling, we concatenate the first-stage features with resolution-matched input images (obtained via average pooling)—a strategy inspired by ESPNetv2 [33] that is proven to preserve low-level spatial cues critical for depth boundary prediction. The concatenated feature map is then downsampled to $[eqn]$ via a $[eqn]$ convolution with stride = 2.

Cross-stage feature correlations are established by cascading features from previous downsampling layers (similar to ResNet’s residual connections), which theoretically ensures unobstructed gradient flow during deep network training and avoids the vanishing gradient problem. For subsequent third and fourth stages, we integrate CMOGA modules and MambaSync modules in a cascaded manner—this integration is not arbitrary but a targeted solution to two core limitations of existing CNN-based encoders: (1) insufficient modeling of mid-order feature interactions (e.g., object contours and part structures) that bridge low-level details and high-level semantics; (2) inefficient global context modeling with prohibitive computational complexity. Following the same downsampling principle, the encoder generates high-order semantic features with dimensions $[eqn]$ and $[eqn]$ , ultimately forming a multi-scale feature pyramid that balances fine-grained information preservation and deep semantic extraction.

Three distinct depth encoder variants have been systematically designed via modular architecture differentiation, with each variant featuring unique channel configurations and CMOGA block parameterization strategies. The technical specifications of these design paradigms are comprehensively documented in Table 1. Meanwhile, the architectural frameworks for the multi-order aggregation mechanism in the CMOGA module and the details of the MambaSync modules are visually analyzed in Figure 2.

3.1.1. Continuous Multi-Order Gated Aggregation (CMOGA)

The CMOGA module is theoretically designed to address the mid-order feature modeling gap in existing lightweight monocular depth estimation models. Prior works predominantly focus on fusing low-order texture features or high-order semantic features, while ignoring mid-order features (e.g., object contours, part relationships) that are essential for accurate depth structure prediction. Conceptually inspired by MogaNet [34], the CMOGA module retains the core design of complementary spatial aggregation (SA) and channel aggregation (CA) branches, but tailors hyperparameters (dilation rates, number of repeated blocks) specifically for dense prediction tasks. This targeted adjustment effectively strengthens mid-order feature interaction without altering the fundamental architecture, achieving a balance between performance improvement and computational cost control.

Overall Architecture of CMOGA Module

The CMOGA module follows a residual learning framework to enhance multi-order feature interaction for dense depth prediction, which is proven to facilitate feature fusion by preserving original input information while adding enhanced representations. Given an input feature tensor $[eqn]$ (where H, W, and C denote the height, width, and channel number of the feature map, respectively), the module generates the enhanced feature tensor $[eqn]$ through sequential computation, formally defined as:

$$[eqn]$$ $$[eqn]$$

where $[eqn]$ and $[eqn]$ encapsulate the core operations of the Spatial Aggregation (SA) and Channel Aggregation (CA) branches (detailed in subsequent paragraphs). Notably, the residual connection $[eqn]$ ensures the preservation of original fine-grained features while fusing multi-order semantic representations, which is crucial for retaining depth boundary accuracy in dense estimation tasks.

Spatial Aggregation (SA) Branch

The SA branch captures multi-scale spatial context through a Feature Decomposition (FD) module followed by a Multi-Order Gated Aggregation (MOGA) block, a design that aligns with the human visual system’s hierarchical perception of spatial structures. The FD module suppresses redundant activations and highlights discriminative local features by modeling deviations between local responses and global averages, formulated as:

$$[eqn]$$ $$[eqn]$$

where $[eqn]$ is a learnable channel-wise scale parameter, and $[eqn]$ denotes global average pooling.

The output $[eqn]$ is further processed by parallel depthwise convolutions with dilation rates $[eqn]$ —this multi-dilation design enables the branch to capture local textures ( $[eqn]$ ), mid-range contours ( $[eqn]$ ), and large-scale object structures ( $[eqn]$ ) without increasing computational complexity. These multi-scale features are concatenated along the channel dimension and modulated with a SiLU-based gating mechanism to adaptively weight informative mid-order features:

$$[eqn]$$

where $[eqn]$ correspond to outputs from dilation branches with $[eqn]$ (channel number is split equally to match the concatenation operation). By tuning the dilation rates and block repetition times, this branch effectively reinforces mid-level spatial feature interactions that are critical for dense depth prediction.

Channel Aggregation (CA) Branch

The CA branch complements the SA branch by modeling inter-channel semantic dependencies, adopting a lightweight design to avoid excessive computational overhead. It consists of a sequence of normalization, point-wise, and depthwise convolutions, followed by a channel interaction mechanism, formulated as:

$$[eqn]$$ $$[eqn]$$

The channel interaction operation is defined as:

$$[eqn]$$

where $[eqn]$ is a learnable channel-wise adjustment parameter, and $[eqn]$ denotes a channel reduction mapping (with $[eqn]$ as the channel compression ratio in our experiments). The careful selection of hyperparameters ensures effective aggregation of mid-level semantic channels, improving cross-scale feature integration while maintaining lightweight properties.

While CMOGA leverages MogaNet’s foundational structure, its core innovation lies in the tailored modifications of hyperparameters and repetition strategies. These changes are specifically aimed at boosting mid-level feature interaction and multi-scale fusion—vital for single-image depth prediction. By enhancing feature representation density without compromising computational efficiency, our model achieves superior performance. The effectiveness of these hyperparameter settings is quantitatively validated through ablation studies in Secion 4.5.2, confirming their ability to improve multi-order feature fusion with negligible computational overhead increase.

3.1.2. MambaSync Module

This module is theoretically designed to resolve the computational complexity bottleneck of global context modeling in existing Transformer-based depth estimation models. As shown in Figure 3, it employs two complementary branches to jointly capture local and global representations: a depthwise convolution (DWConv) branch for extracting fine-grained spatial features, and a Hidden State Mixer based State Space Duality (HSMSSD) [17] branch for hierarchical global context aggregation. To enhance feature fusion, a squeeze-and-excitation (SE) block is integrated to dynamically recalibrate channel-wise responses, facilitating adaptive balancing between local and global semantic cues.

The overall mechanism of MambaSync follows a dual-branch fusion framework, formally formulated as:

$$[eqn]$$

where $[eqn]$ and $[eqn]$ are the output feature tensors from the DWConv and HSMSSD branches, respectively (C, H, W denote channel number, height, and width of feature maps). The SE block adaptively fuses local and global features by applying dynamic channel-wise weighting, ensuring that informative features are emphasized in the final representation.

Global Feature Extraction

Given an input feature tensor $[eqn]$ , the HSMSSD branch models long-range dependencies using a state space representation, which reduces computational cost from $[eqn]$ to $[eqn]$ (where L = H × W denotes the number of spatial tokens, $[eqn]$ denotes feature dimension, and N denotes the number of hidden states). This linear complexity is achieved by projecting high-dimensional spatial features into a compressed latent space, enabling efficient global context modeling.

The input is first projected and convolved to generate latent state parameters:

$$[eqn]$$

where $[eqn]$ is the input mixing matrix, $[eqn]$ is the output projection matrix, and $[eqn]$ is the learnable time-step vector for dynamic state transition. A normalized transition matrix $[eqn]$ is then computed as:

$$[eqn]$$

where $[eqn]$ is the initial transition matrix initialized with small random values.

State update and output generation are performed as follows:

$$[eqn]$$ $$[eqn]$$

where $[eqn]$ denotes the batch size, $[eqn]$ is the flattened projection of input $[eqn]$ , $[eqn]$ denotes the hidden state tensor, and $[eqn]$ is the intermediate global feature tensor (resized back to $[eqn]$ for subsequent fusion).

To enhance non-linearity and improve feature representation capability, a gated activation mechanism is introduced:

$$[eqn]$$ $$[eqn]$$

where $[eqn]$ represents the dimension of the inner gated state, $[eqn]$ is a predefined expansion factor (set to 4 in our experiments), and $[eqn]$ is a learnable gating weight matrix.

Local Feature Extraction

To preserve spatial detail and texture information (critical for depth boundary prediction), the local branch consists of a lightweight convolutional block. Specifically, a $[eqn]$ depthwise convolution is followed by batch normalization, GELU activation, and a $[eqn]$ pointwise convolution to aggregate channel-wise responses while maintaining spatial resolution:

$$[eqn]$$

where $[eqn]$ is the input feature tensor, BatchNorm2d denotes 2D batch normalization (explicitly specified to avoid ambiguity), and $[eqn]$ is the output local feature tensor.

The channel-wise recalibrated fusion of these two branches endows MambaSync with both robust modeling capability and high computational efficiency. Furthermore, the coordinated interaction between CMOGA (specialized in mid-order feature enhancement) and MambaSync (focused on efficient global context modeling) strikes a favorable balance between effective feature extraction and inference speed, forming a coherent system well-suited for resource-constrained dense prediction tasks such as monocular depth estimation.

3.2. Depth Decoder

Our decoder design follows Lite-Mono [10]. It progressively upsamples encoder features using bilinear interpolation combined with lightweight convolutional layers, while incorporating skip connections from three intermediate encoder stages. To enable multi-scale supervision, three prediction heads generate inverse depth maps at full, half, and quarter resolutions. This design achieves a favorable balance between accuracy and efficiency, ensuring the decoder remains lightweight and directly comparable across methods.

3.3. PoseNet

For relative pose estimation, we also adopt the design of LiteMono [10] to ensure a fair comparison. A ResNet18 backbone extracts features from image pairs, and a lightweight convolutional decoder estimates the 6-DoF camera transformation between consecutive frames. Since previous studies [13,35] report only marginal gains from more complex pose networks, we retain this efficient design in order to isolate and evaluate the contributions of our encoder.

3.4. Self-Supervised Learning

Following Lite-Mono [11], we adopt a self-supervised learning strategy based on image reconstruction, incorporating photometric consistency, edge-aware smoothness, and multi-scale supervision to train depth and pose networks without ground-truth labels.

Dual-Network Joint Modeling To decouple scene geometry from camera motion, we adopt a dual-network architecture:

• DepthNet:

A convolutional encoder-decoder network that predicts inverse depth maps $[eqn]$ from a single target frame $[eqn]$ . A sigmoid activation followed by linear scaling is used to constrain the depth range. Multi-scale outputs help capture both global structure and fine-grained details.

PoseNet:

A lightweight CNN that estimates the 6-DoF relative camera pose $[eqn]$ from adjacent frame pairs ( $[eqn]$ or $[eqn]$ ), decomposed into rotation R and translation t.

Differentiable View Synthesis Given the predicted depth and pose, the target frame is reconstructed by warping source images using a differentiable projection model. Let $[eqn]$ denote the camera intrinsic matrix (calibrated using KITTI’s average focal length as detailed in Section 4.1.1), $[eqn]$ and $[eqn]$ denote pixel coordinates in the source and target frames, respectively, and $[eqn]$ , $[eqn]$ denote the depth tensors at the corresponding pixels. The projection relation is formulated as:

$$[eqn]$$ $$[eqn]$$

Photometric Reconstruction Loss To guide learning, we employ a photometric loss that combines structural similarity (SSIM) and L1 pixel-wise error. Let $[eqn]$ denote the balance coefficient between the two terms:

$$[eqn]$$ $$[eqn]$$ $$[eqn]$$

where $[eqn]$ is an auto-masking flag that filters dynamic objects or occluded regions (set to 1 if the source frame reconstruction error is larger than the target frame self-reconstruction error, and 0 otherwise).

Edge-Aware Depth Smoothness To encourage smooth depth predictions while preserving object boundaries, we incorporate an edge-aware regularization term. Let $[eqn]$ denote the set of all pixel coordinates in the image:

$$[eqn]$$

Multi-Scale Supervision Depth maps are predicted at three resolutions: full ( $[eqn]$ ), half ( $[eqn]$ ), and quarter ( $[eqn]$ ). The overall training loss is computed as, where $[eqn]$ is the weight of the smoothness term:

$$[eqn]$$

4. Experiments

This chapter introduces the datasets used in training and validation, followed by comparative analyses demonstrating the advantages of the proposed method over existing approaches. Subsequent experiments evaluate the efficiency of inference, whereas ablation studies systematically verify the contributions of key components.

4.1. Datasets

4.1.1. KITTI

The KITTI dataset [18], a widely recognized benchmark in autonomous driving and robotics research, comprises 61 meticulously curated stereo road scenes. Its multisensor data acquisition system integrates advanced instrumentation, including binocular camera arrays, 3D LiDAR units, and high-precision GPU/IMU inertial navigation modules. To facilitate algorithm development and performance evaluation, this study uses an eigenvalue-based hierarchical data partitioning strategy [32], structuring the original dataset into three distinct subsets: a training set containing 39,180 monocular image triplets with various traffic scenarios and illumination conditions, a validation set comprising 4424 samples, and a testing set consisting of 697 instances. This rigorous pyramidal data partition establishes a systematic framework for reliable performance validation.

Our self-supervised training methodology relies on the known intrinsic parameters of the camera, as originally described in [6]. By calculating the average focal length for all KITTI images, we implement a unified intrinsic calibration protocol during network optimization. During evaluation, predicted depth values are constrained within the [0, 80] m interval, following established industry standards for depth estimation benchmarks.

4.1.2. Make3D

The Make3D dataset [19], a comprehensive benchmark for computer vision and depth estimation tasks, consists of 534 training images (2272 × 1704 pixels) and 134 test images. This data set uses multiview stereo image pairs (baseline distance 12 cm) captured through LiDAR camera fusion systems to generate geometrically diverse 3D scene representations. High-precision pixel-accurate depth annotations (error < 5%) are produced using photometric stereo reconstruction with rigid multi-sensor calibration. The dataset encompasses urban street environments, highway scenarios, and synthetic test cases with extreme lighting conditions, nonrigid occlusions, and physically implausible object configurations. These artificial augmentations aim to transcend the physical limitations of real-world data by creating photorealistic but structurally novel depth maps. Our experiments utilize Make3D to evaluate cross-domain generalization capabilities of models trained in KITTI, ensuring robust performance across heterogeneous outdoor environments with diverse visual characteristics and geometric complexities.

4.2. Implementation Details

Our method is implemented in PyTorch 2.6.0 and trained on a single NVIDIA RTX 3090 GPU using a batch size of 12. We adopt AdamW [36] as the optimizer with a weight decay of $[eqn]$ . To improve model generalization, we employ two complementary regularization strategies: DropPath regularization is applied within both the CMOGA and MambaSync modules, while data augmentation is adopted as a preprocessing step to enhance training robustness. Specifically, during training we perform the following augmentations with 50% probability each: horizontal flips, brightness adjustment (±0.2), saturation adjustment (±0.2), contrast adjustment (±0.2), and hue jitter (±0.1).

For models trained from scratch, the initial learning rate is set to $[eqn]$ , following a cosine annealing schedule [37], and the total number of training epochs is set to 30. Pretraining on ImageNet [38] significantly accelerates network convergence, so when pretrained weights are used, we reduce the initial learning rate to $[eqn]$ and train for 30 epochs.

4.3. Evaluation Metrics

Depth estimation performance is evaluated using seven standard metrics from [2], capturing both absolute and relative errors while balancing global and local accuracy. AbsRel measures the percentage deviation from ground truth, and SqRel emphasizes larger errors via squared normalization. RMSE and RMSE log reflect global error, with the latter offering robustness to scale variation. The threshold metrics $[eqn]$ < 1.25, $[eqn]$ < 1.25^2^, and $[eqn]$ < 1.25^3^ indicate the percentage of pixels where estimates fall within 12.5%, 31.6%, and 70.8% of the true depth. Together, these metrics offer a comprehensive and practical evaluation of depth estimation models.

4.4. Results

4.4.1. KITTI Results

Table 2 compares MogaDepth with existing lightweight depth estimation methods under strictly comparable parameter budgets (2.0–3.4 M), providing a comprehensive assessment of depth estimation accuracy across core metrics (Abs Rel, Sq Rel, RMSE, etc.). It should be emphasized that performance evaluation is based on peer-to-peer comparison of models with similar complexity—direct comparison with models of significantly higher parameter counts (e.g., DNA-Depth-B1 with 6.7 M parameters, Sun et al. with 10.9 M parameters) is inappropriate for lightweight model assessment. Objectively, MogaDepth does not achieve leading performance in all indicators among models with comparable parameter scales; instead, it demonstrates targeted optimization in key metrics while maintaining competitive performance in others, which aligns with the design goal of prioritizing inference efficiency for resource-constrained platforms.

Specifically, focusing on models with similar parameter sizes (2.0–3.4 M), our standard MogaDepth (3.4 M parameters) outperforms the representative lightweight architecture LDA-Mono-L (2.0 M parameters) in two core metrics sensitive to large-scale depth prediction errors and global consistency: the SqRel metric is reduced from 0.765 to 0.745 (2.6% reduction) and the RMSE metric is reduced from 4.535 to 4.504 (0.68% reduction). From a theoretical perspective, the reduction in SqRel stems directly from the CMOGA module’s mid-order feature modeling capability: by explicitly capturing object contours and part-level spatial structures, CMOGA mitigates over-smoothing in texture-less regions and erroneous depth assignments at object boundaries—issues that often lead to large deviation errors heavily penalized by squared relative error calculations. The decrease in RMSE further validates the effectiveness of the MambaSync module’s linear-complexity global context modeling: unlike traditional Transformer-based attention mechanisms with quadratic complexity, MambaSync captures long-range spatial dependencies (e.g., relative depth between distant objects and background) without expanding parameter overhead, reducing the overall variance of depth predictions across the entire image and lowering the root mean square error. For other metrics, MogaDepth maintains performance comparable to state-of-the-art lightweight models: its Abs Rel (0.104) is on par with LDA-Mono-L (0.104), and the threshold-based accuracy metrics ( $[eqn]$ , $[eqn]$ ) reach 0.964 and 0.984 respectively—consistent with Lite-Mono (3.1M parameters, 0.963/0.983) and LDA-Mono-L (0.964/0.983), indicating that the efficiency-oriented architectural design does not lead to significant accuracy degradation.

As visualized in Figure 4, MogaDepth delivers clearer geometric structures, sharper object boundaries, and smoother depth transitions in texture-less or distant regions—qualitative results that are consistent with the optimized SqRel and RMSE metrics in Table 2. These qualitative advantages further verify the synergistic effect of CMOGA and MambaSync modules in enhancing the structural fidelity of depth maps. To fully evaluate the model’s practical value, we further integrate the above accuracy results with complexity and inference speed analysis (detailed in the following section), as MogaDepth’s core design goal lies in balancing accuracy and efficiency for resource-constrained scenarios.

4.4.2. Complexity and Speed Evaluation

We evaluated MogaDepth on both an NVIDIA RTX 3090 GPU and the Jetson Xavier edge platform, focusing on parameter count, FLOPs, and inference time—key metrics for assessing deployability in resource-constrained scenarios. As shown in Table 3, MogaDepth achieves a superior balance between model size, computational cost, and inference speed compared to the listed lightweight methods, which compensates for its lack of leading performance in partial accuracy metrics.

Specifically, under comparable input dimensions, MogaDepth-Tiny, MogaDepth-Small, and the standard MogaDepth run approximately 4%, 18%, and 13% faster than their corresponding Lite-Mono variants, respectively. This consistent speed advantage across all three model variants highlights the inherent efficiency of our Mamba-based architecture, which is a core innovation distinguishing MogaDepth from attention-based lightweight models. The key to this efficiency lies in the fundamental architectural difference between Mamba and conventional self-attention mechanisms: while Lite-Mono [10] and our model have similar parameter counts and FLOPs, attention-based models are bottlenecked by frequent memory access to large key-value matrices, especially for long-sequence high-resolution feature maps. In contrast, Mamba employs a linear recurrent formulation, which eliminates the quadratic complexity of attention. During inference, it maintains only a compact hidden state for each new token, minimizing repeated memory access and improving cache utilization. This design fundamentally reduces latency, enabling MogaDepth to achieve faster inference on both high-performance GPUs and edge devices while preserving comparable accuracy.

Combined with the KITTI accuracy results, these findings demonstrate that MogaDepth strikes a favorable trade-off between depth estimation accuracy and inference efficiency that is tailored for resource-constrained scenarios. For real-world applications such as mobile robotics and embedded autonomous driving—where computational resources are limited and real-time performance is critical—MogaDepth’s balanced design offers greater practical value than models that pursue top accuracy at the cost of efficiency.

4.4.3. Make3D Results

As presented in Table 4 and qualitatively validated in Figure 5, the effectiveness of MogaDepth on the Make3D dataset is evidenced by consistent improvements across all evaluation metrics compared with existing methods. In particular, when compared with R-MSFMX6-GC [16], MogaDepth achieves a 10.9% reduction in Abs Rel (0.285 vs. 0.290), an 11.6% reduction in Sq Rel (2.789 vs. 2.911), a slight improvement in RMSE log (0.150 vs. 0.151), and a marginally lower RMSE (6.409 vs. 6.418).

These results suggest that MogaDepth can be effectively adapted to diverse depth distributions and remains robust in challenging scenarios, including low-texture regions and significant domain shifts. Overall, the consistent gains in both in-domain and cross-domain evaluations demonstrate that MogaDepth generalizes well beyond its training distribution and exhibits strong adaptability to unseen environments.

4.5. Ablation Study

4.5.1. Model Architectures

To rigorously verify the design superiority of the core components (CMOGA and MambaSync), we conduct an ablation study on the KITTI benchmark under a strict fixed parameter budget constraint (3.4 M, consistent with the full MogaDepth model). The input size is fixed at $[eqn]$ for all experiments.

Specifically, when removing a target module (MambaSync or CMOGA), we compensate for the reduced parameters by adjusting the number of convolution layers in redundant layers of the backbone.This design ensures that the performance difference between models is solely caused by the structural advantages of the proposed modules, rather than parameter scaling. All training hyper-parameters (learning rate, optimizer, epochs, etc.) are kept identical to eliminate additional interference.

Quantitative results in Table 5 demonstrate that removing either CMOGA or MambaSync leads to consistent degradation in depth estimation accuracy (e.g., increased Abs Rel and RMSE, decreased $[eqn]$ ), even with the same total parameters. This fully validates the indispensability and rationality of our module design for balancing accuracy and efficiency.

CMOGA blocks. The CMOGA module enhances multi-scale and mid-order feature integration, which is often underexplored in lightweight monocular depth estimation. Ablation results confirm that CMOGA significantly improves the network’s ability to capture both fine-grained geometric details and global scene structure.

MambaSync blocks. MambaSync balances global context modeling and local feature preservation using hierarchical state-space modeling and lightweight convolutions. Ablation demonstrates that it effectively improves depth prediction accuracy while maintaining computational efficiency, validating its importance for real-time, lightweight monocular depth estimation.

4.5.2. Dilation Rates

We study the impact of different dilation rate settings in the CMOGA module for lightweight monocular depth estimation. Three configurations are evaluated:

• Default (ours): For Stage 1 and Stage 2, SA blocks employ $[eqn]$ repeated n times, followed by a final block of $[eqn]$ . For Stage 3, the CMOGA sequence is repeated three times, each consisting of $[eqn]$ repeated 2 times followed by $[eqn]$ . In other words, the full sequence is $[eqn]$ .
• Alternative 1: Follows the same stage-wise structure as Default, but replaces all occurrences of $[eqn]$ with $[eqn]$ and $[eqn]$ with $[eqn]$ in the sequences.
• Alternative 2: Follows the same stage-wise structure as Default, but replaces all occurrences of $[eqn]$ with $[eqn]$ .
• MogaNet baseline: Original MogaNet setup: $[eqn]$ repeated n times, with the last block $[eqn]$ in each stage.

As shown in Table 6 our default configuration effectively enhances mid-order feature fusion while preserving multi-scale context, making it particularly suitable for lightweight monocular depth estimation. Alternative configurations show minor reductions in performance, supporting the choice of our hyperparameters as both effective and reasonable for the task.

4.5.3. Module Comparison: CDC vs. CMOGA

To further validate the superiority of our CMOGA in capturing mid-order features over existing progressive dilation designs, we conduct a controlled experiment where we replace the CMOGA module in our full model with a CDC module while keeping all other components (including LGFI) and architectural settings identical. This ensures a fair comparison that isolates the impact of the core aggregation module design. Quantitative results in Table 7 show that our CMOGA-based model consistently outperforms the CDC-based counterpart across all major metrics on the KITTI benchmark. Notably, the improvement in RMSE (from 4.589 to 4.504) and $[eqn]$ (from 0.886 to 0.891) highlights CMOGA’s enhanced capability in preserving structural details and depth accuracy. These results confirm that explicit modeling of mid-order feature interactions, as implemented in CMOGA, provides more effective feature representations than CDC’s progressive dilation approach, which primarily focuses on receptive field expansion.

4.5.4. MambaSync Module Ablation Analysis

The MambaSync module fuses complementary local and global features, with an SE module balancing their contributions. To verify the necessity of each component, we built four variants by establishing different components, keeping all other experimental settings consistent for fairness.

As shown in Table 8, the full MambaSync module (integrating both local and global branches with the SE gating) achieves the best performance across all metrics. Removing either the local or global branch leads to a noticeable drop in accuracy, confirming that both types of features are complementary and necessary for robust depth estimation. Specifically, the absence of the local branch results in the largest degradation in Sq Rel (from 0.728 to 0.797), indicating that fine-grained geometric details are crucial for reconstructing dense depth maps. Meanwhile, removing the global branch moderately increases RMSE (from 4.504 to 4.635), underscoring the importance of long-range contextual information for overall scene coherence. Furthermore, ablating the SE gating mechanism (Local + Global without SE) causes a consistent, though slight, performance decline, which verifies that adaptive feature recalibration helps to optimally fuse the two branches. These ablation results collectively validate the design rationale of the MambaSync module and highlight the contribution of each component to the final depth estimation performance.

5. Conclusions

In this paper, we have presented MogaDepth, a lightweight and efficient architecture for self-supervised monocular depth estimation. By integrating convolutional backbones with Mamba-based components, and introducing the CMOGA and MambaSync modules, MogaDepth effectively captures mid-order feature interactions and long-range global dependencies. Extensive experiments on KITTI and Make3D demonstrate that MogaDepth achieves highly competitive performance while maintaining a compact model size and strong generalization to unseen domains. Importantly, MogaDepth also offers significant improvements in inference speed on edge devices, achieving up to 13% faster processing without sacrificing accuracy, highlighting its suitability for real-time applications in resource-constrained environments. Ablation studies further validate the contribution of both CMOGA and MambaSync to improved depth accuracy and feature representation.

Future work will focus on further enhancing mid-order feature modeling, integrating multi-modal information, and optimizing performance for resource-constrained platforms, with the goal of improving depth estimation under challenging scenarios such as extreme lighting conditions and dynamic environments.