FlexDepth: Adaptive Monocular Depth Models

• FlexDepth is a flexible family of self-supervised monocular depth estimation models that adapts to varying scales and dynamic scenes in driving environments.
• It employs a two-stage training strategy with a static-dynamic decoupling mechanism and a Scale-Driven Decoder to overcome fixed design limitations and improve key performance metrics.
• Variants from Flex-Nano to Flex-X-Large enable tailored trade-offs in accuracy and efficiency, facilitating robust deployment on edge devices in real-world scenarios.

FlexDepth is a scale-driven and flexible family of self-supervised monocular depth estimation models tailored for challenging road scenarios. In its explicit formulation, it addresses two recurrent weaknesses of self-supervised driving depth systems: fixed decoder designs that do not scale well across model sizes, and the failure of static-scene photometric assumptions in the presence of dynamic traffic participants. The framework combines a two-stage static-dynamic decoupled training strategy with a Scale-Driven Decoder (SDD), and is instantiated as a model family ranging from Flex-Nano to Flex-X-Large (Zhu et al., 1 Jul 2026). A broader methodological reading is also suggested by adjacent work: “FlexDepth” can denote a class of depth systems that adapt depth representations across scales, tasks, domains, modalities, and temporal regimes, rather than treating depth as a single fixed output format.

1. Definition and problem setting

FlexDepth addresses self-supervised monocular depth estimation from driving videos. The training signal comes from unlabeled monocular sequences: given a target frame $I_t$, the network predicts a dense depth or disparity map $D_t$ or $\text{disp}_t$, and supervision is induced by view synthesis and photometric consistency with adjacent frames. The design is explicitly motivated by two limitations of prior self-supervised MDE systems. First, many methods use a fixed encoder-decoder pipeline with hand-designed upsampling that compresses already low-resolution deep features before spatial recovery, which degrades high-level cues and harms boundary quality, especially in lightweight models. Second, the rigid-scene assumption behind photometric reprojection is violated by moving vehicles, cyclists, pedestrians, occlusions, and disocclusions, while many dynamic-scene remedies rely on semantics, optical flow, pseudo-labels, or heavy multi-frame pipelines that are difficult to deploy on edge hardware (Zhu et al., 1 Jul 2026).

The framework defines a model family—Flex-Nano, Flex-Small, Flex-Medium, Flex-Large, and Flex-X-Large—built around three components: a YOLOv11-derived multi-scale encoder, a scale-aware decoder that changes with model size, and a two-stage training procedure that first learns standard self-supervised depth and then re-trains the depth network with an adaptive static-dynamic mask. The same design is intended to cover multiple accuracy-efficiency operating points, rather than optimizing a single architecture for a single budget (Zhu et al., 1 Jul 2026).

2. Self-supervised formulation and static-dynamic decoupling

In Stage 1, FlexDepth jointly trains a depth network and a PoseNet. PoseNet uses a ResNet-18 encoder with a 4-layer decoder to estimate the relative pose $P_{t\to s}$ between the target frame $I_t$ and source frames $I_s$. The target image is reconstructed by differentiable warping,

$$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$

where $K$ is the camera intrinsic matrix. The photometric loss is

$$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$

with $\alpha = 0.85$. For multiple source views, FlexDepth uses minimum reprojection with auto-masking,

$D_t$0

and combines it with edge-aware smoothness on mean-normalized inverse depth,

$D_t$1

The Stage-1 multi-scale objective is

$D_t$2

After Stage 1, early-stage and late-stage depth snapshots are retained, producing $D_t$3 and $D_t$4 (Zhu et al., 1 Jul 2026).

The central observation behind Stage 2 is that dynamic regions are less stable across epochs than static background regions. FlexDepth therefore defines a static-dynamic decoupled mask

$D_t$5

with $D_t$6. Here $D_t$7 and $D_t$8 are intermediate feature maps from early and late stages, $D_t$9 is a discrepancy representation, and $\text{disp}_t$0 is a small CNN that predicts an image-specific threshold. Stage 2 freezes PoseNet and re-trains only the depth network using a masked probabilistic loss

$\text{disp}_t$1

with $\text{disp}_t$2, together with anisotropic geometric depth smoothing,

$\text{disp}_t$3

where $\text{disp}_t$4. The Stage-2 loss is

$\text{disp}_t$5

This decoupling is empirically nontrivial. On KITTI, Flex-X-Large without Stage 2 reports AbsRel $\text{disp}_t$6, SqRel $\text{disp}_t$7, RMSE $\text{disp}_t$8, and $\text{disp}_t$9; with Stage 2 and the adaptive mask, these become AbsRel $P_{t\to s}$0, SqRel $P_{t\to s}$1, RMSE $P_{t\to s}$2, and $P_{t\to s}$3. In dynamic-region analysis, it reports moving-object AbsRel $P_{t\to s}$4 versus $P_{t\to s}$5 for DSI-MonoViT, and moving-object SqRel $P_{t\to s}$6 versus $P_{t\to s}$7 (Zhu et al., 1 Jul 2026).

3. Scale-Driven Decoder

The architectural core of FlexDepth is the Scale-Driven Decoder. At level $P_{t\to s}$8, the decoder is written as

$P_{t\to s}$9

where $I_t$0 is the encoder feature, $I_t$1 is the coarser decoder feature, $I_t$2 is the upsampling operator, $I_t$3 is the post-convolution module, and $I_t$4 is the prediction head. A defining design choice is the removal of the pre-convolution stage found in many U-Net-like decoders, on the grounds that deep features are already information-sparse and should not be compressed before spatial recovery (Zhu et al., 1 Jul 2026).

For small models, $I_t$5 is instantiated as the High-Efficiency Bottleneck (HEB). Given $I_t$6, a convolution and channel split produce

$I_t$7

followed by a dense sequence

$I_t$8

and an output fusion

$I_t$9

For larger models, $I_s$0 becomes the High-Performance Bottleneck (HPB), using a CSP-style structure,

$I_s$1

The decoder therefore changes with scale: HEB emphasizes optimization and dense gradient flow in low-FLOP regimes, whereas HPB prioritizes richer local feature modeling in higher-capacity models (Zhu et al., 1 Jul 2026).

Upsampling is likewise content-aware. Rather than fixed bilinear interpolation, FlexDepth predicts sampling offsets and applies GridSample after PixelShuffle:

$I_s$2

where $I_s$3 is the regular sampling grid, $I_s$4 are learned offsets, and $I_s$5 is the upsampling scale. The prediction head is also scale-dependent: smaller models use a conventional “predict then upsample” head, while larger ones use an inverted head that upsamples features first and predicts depth afterward. This scale-aware decoder is not confined to the FlexDepth family; when plugged into MonoViT, the reported configuration reduces computation from $I_s$6 GFLOPs to $I_s$7 GFLOPs and improves KITTI AbsRel from $I_s$8 to $I_s$9 (Zhu et al., 1 Jul 2026).

4. Model family, efficiency, and empirical performance

FlexDepth is explicitly organized as a deployment-oriented family rather than a single network.

Variant	GFLOPs	Representative figures
Flex-Nano	0.718	1.52 M parameters; 37.6 FPS on Snapdragon 8 Elite
Flex-Small	2.78	6.06 M parameters; 18.6 FPS on Snapdragon 8 Elite
Flex-Medium	9.99	12.7 M parameters; 5.8 FPS on Snapdragon 8 Elite
Flex-Large	11.52	15.2 M parameters
Flex-X-Large	24.56	32.3 M parameters; 3.0 FPS on Snapdragon 8 Elite

On KITTI, Flex-Nano reports AbsRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$0 at $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$1 GFLOPs, Flex-Small reports AbsRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$2, SqRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$3, RMSE $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$4, and $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$5 at $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$6 GFLOPs, Flex-Medium reports AbsRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$7, and Flex-Large reports AbsRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$8. Flex-X-Large reports AbsRel $$\hat{I}_t = I_s\big\langle \text{proj}(\hat{D}_t, P_{t\to s}, K)\big\rangle,$$9, SqRel $K$0, RMSE $K$1, and $K$2, outperforming reported self-supervised baselines such as MonoViT, FGTO, DSI-MonoViT, and Self-Distillation while using substantially fewer FLOPs. On Cityscapes, Flex-X-Large reports AbsRel $K$3, SqRel $K$4, RMSE $K$5, and $K$6, again surpassing prior dynamic-scene methods such as ProDepth, FGTO, and DSI-MonoViT at lower computational cost (Zhu et al., 1 Jul 2026).

The family also emphasizes zero-shot behavior. On Make3D, KITTI-trained Flex-X-Large reports AbsRel $K$7, RMSE $K$8, and RMSElog $K$9, better than the self-supervised baselines listed in the comparison. Under fair LS alignment and improved KITTI ground truth, Flex-X-Large at $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$0 reports AbsRel $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$1, $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$2, $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$3 M parameters, and $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$4 GFLOPs, compared with Depth Anything v2 ViT-L at $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$5, which reports AbsRel $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$6, $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$7, $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$8 M parameters, and $$L_p = \alpha \frac{1 - \text{SSIM}(\hat{I}_t, I_t)}{2} + (1-\alpha)\|\hat{I}_t - I_t\|_1,$$9 GFLOPs. This comparison suggests that in-domain self-supervision can rival or exceed zero-shot foundation depth models at much lower cost in the driving regime (Zhu et al., 1 Jul 2026).

5. Broader “FlexDepth” interpretations in depth research

A broader interpretation of FlexDepth is suggested by several adjacent systems: depth is treated as a representation that should be adaptable across domains, tasks, temporal horizons, resolutions, and conditioning signals, rather than as a fixed dense map predicted in one shot.

Work	Setting	Flexibility axis
PopNet (Wu et al., 2022)	Source-free depth for object pop-out and segmentation	Frozen depth model adapted to SOD/COD via OPN and contact surface
PDDM (Yang et al., 2024)	Image-guided depth completion	Scene-adaptive depth bins, progressive decoupling, multi-scale supervision
FlashDepth (Chou et al., 9 Apr 2025)	Streaming video depth estimation	2K, 24 FPS, high/low-resolution hybrid with temporal alignment
Amodal Depth Anything (Li et al., 2024)	Object-conditioned amodal relative depth	Occluded geometry from $\alpha = 0.85$0
DD3Dv2 (Park et al., 2022)	Monocular 3D detection	In-domain depth adaptation using LiDAR or RGB videos
Depth Any Video (Yang et al., 2024)	Variable-length video depth estimation	Mixed-duration training and keyframe interpolation up to 150 frames

In "Source-free Depth for Object Pop-out" (Wu et al., 2022), a frozen DPT+Boosting depth network is adapted to salient and camouflaged object detection through an Object Popping Network and a learned contact surface $\alpha = 0.85$1, enabling a depth-based pseudo-mask $\alpha = 0.85$2. In "Progressive Depth Decoupling and Modulating for Flexible Depth Completion" (Yang et al., 2024), flexibility is identified with scene-adaptive discretization: the Bins Initializing Module derives seed bins from sparse depth, an incremental depth decoupling branch refines them from global to local, and a modulating branch refines probability maps from coarse to fine; the reported ablation shows PDDM improving from UD $\alpha = 0.85$3 and SID $\alpha = 0.85$4 to AbsRel $\alpha = 0.85$5 and RMSE $\alpha = 0.85$6.

In video, "FlashDepth" (Chou et al., 9 Apr 2025) converts a pretrained single-image model into a streaming 2K depth system, running at $\alpha = 0.85$7 and $\alpha = 0.85$8 FPS by inserting a small Mamba temporal module into decoder features and pairing a high-resolution small model with a low-resolution large model via cross-attention. "Depth Any Video with Scalable Synthetic Data" (Yang et al., 2024) extends flexibility differently: it builds a synthetic dataset of $\alpha = 0.85$9 video clips and about $D_t$00M frames, adopts mixed-duration training with frame dropout and RoPE, and uses keyframe-based interpolation to handle videos up to about $D_t$01 frames. "Amodal Depth Anything" (Li et al., 2024) defines amodal depth estimation as object-conditioned prediction of invisible geometry from $D_t$02, introduces the $D_t$03K-image ADIW dataset, and reports a $D_t$04 improvement in accuracy over the previous SoTA on ADIW. "Depth Is All You Need for Monocular 3D Detection" (Park et al., 2022) treats depth as the central transferable representation for 3D detection and shows DD3Dv2 improving nuScenes test performance from mAP $D_t$05, NDS $D_t$06 to mAP $D_t$07, NDS $D_t$08 when depth is adapted in-domain with LiDAR supervision.

Taken together, these systems suggest that “FlexDepth” is not only a model family name but also a design stance: depth models should be target-adaptive, modular, and able to bend toward different downstream constraints without discarding pretrained geometric knowledge.

6. Limitations and research directions

As a concrete self-supervised driving system, FlexDepth remains driving-centric. Its reported limitations include limited applicability to indoor scenes with irregular textures, clutter, and close-range occlusions; no explicit treatment of severe weather, night-time, lens dirt, or sensor noise; an assumption of fixed camera intrinsics and reasonably calibrated pinhole geometry; and the standard scale ambiguity of self-supervised monocular depth, which still requires alignment for metric evaluation (Zhu et al., 1 Jul 2026).

The broader literature suggests several plausible extensions. One direction is stronger temporal and streaming support: FlashDepth emphasizes recurrent temporal alignment at real-time 2K resolution, while Depth Any Video emphasizes mixed-duration training and long-sequence interpolation (Chou et al., 9 Apr 2025, Yang et al., 2024). Another is extending beyond visible surfaces: Amodal Depth Anything frames occluded geometry as a relative-depth problem conditioned on amodal masks, and PopNet frames foreground extraction as reasoning over a contact surface in 3D (Li et al., 2024, Wu et al., 2022). A third is deeper task adaptation: DD3Dv2 uses depth as an in-domain auxiliary task for monocular 3D detection, and PDDM uses scene-adaptive discretization to tailor depth completion to the observed depth distribution (Park et al., 2022, Yang et al., 2024). A plausible implication is that future FlexDepth systems will combine scale-aware self-supervised training with temporal adaptation, amodal conditioning, and scene-adaptive depth representations, while preserving the deployment discipline that motivated the original FlexDepth family.