MetricNav: Metric Grounding for Navigation

• MetricNav is a metric-grounded framework that integrates MetricNet’s scale prediction to convert abstract waypoint sequences into real-world executable trajectories.
• It addresses the deployment mismatch by replacing fixed-scale, velocity-controlled navigation with a supervised regressor and position control that enhances obstacle avoidance.
• The framework further refines paths using diffusion guidance to balance goal progress and safety, demonstrating improved performance in both simulation and real-world tests.

Searching arXiv for the primary paper and closely related generative navigation policies. Attempting to retrieve arXiv metadata programmatically for citation accuracy. $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$01

The execution environment does not provide external network access, so the article relies on the supplied arXiv metadata and details block for citations. MetricNav is a metric-grounded execution and guidance framework for generative visual-navigation policies such as NoMaD, FlowNav, and NaviDiffusor. In the formulation introduced with MetricNet, a policy predicts a sequence of future $2$D waypoints from recent camera observations and, optionally, a goal image, but those waypoints are produced in an abstract normalized space rather than in real-world coordinates. MetricNav addresses that deployment mismatch by integrating MetricNet, a supervised multimodal regressor that predicts the metric distance between waypoints, with path-segment execution and metric-space diffusion guidance. The resulting framework is intended to make policy outputs executable as real paths, rather than merely directionally plausible waypoint sequences (Nayak et al., 17 Sep 2025).

1. Generative-navigation setting

MetricNav is defined in the context of generative visual-navigation policies that predict future egocentric waypoints directly from observations. Formally, given an observation horizon

$\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$

and an optional goal image $\mathbf{g}_i$, a policy $\pi$ predicts an action sequence

$$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$

where each $\mathbf{a}_t$ is a $2$D waypoint in the robot egocentric frame. The paper characterizes this family of methods as attractive because they can be trained on large heterogeneous datasets and can generalize across scenes and robot embodiments (Nayak et al., 17 Sep 2025).

MetricNav is not introduced as a separate trainable navigation model with its own dataset. It is presented as an integration: a navigation diffusion policy, MetricNet, metric-space guidance, and action selection. This distinction is central to its scope. The base policy remains responsible for generating waypoint sequences; MetricNav changes how those sequences are grounded, guided, and executed.

A recurrent source of confusion in this area is the assumption that a predicted waypoint trajectory is already an executable path. The paper argues that this is not the case for standard deployment of generative policies. The predicted sequence carries path shape information, but without metric grounding and without an execution strategy that follows the path segment, the sequence does not function as a metrically valid motion plan.

2. Structural problems motivating MetricNav

The framework is motivated by two structural flaws in prior deployment practice. The first is that predicted trajectories live in an abstract, normalized space rather than in metric coordinates. The paper defines the true average inter-waypoint distance for a trajectory segment as

$$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$

and uses it to normalize the action sequence during training: $\tilde{A}_i = A_i / \phi_\text{gt}.$ At inference, however, $\phi_\text{gt}$ is unknown, so prior work substitutes a manually selected constant,

$\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$0

often with $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$1. The paper explicitly states that this quantity is not the real-world waypoint spacing, so the output trajectory is not metrically grounded (Nayak et al., 17 Sep 2025).

The second flaw concerns execution. Although the policy predicts a full path, prior systems typically discard most of it and use only one waypoint as the target of a low-level controller. The paper terms this velocity control. If waypoint $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$2 is selected, the robot computes linear and angular commands from that single waypoint, with $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$3, and clips them to $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$4. In this regime, the robot does not execute the predicted path; it simply aims at a short-term waypoint.

The consequences are framed in terms of safety, exploration, and evaluation. A trajectory that would safely curve around an obstacle can still yield a collision if execution cuts the corner and drives directly toward the selected waypoint. Likewise, even a directionally correct abstract trajectory can intersect walls if the chosen scale is too small or too large. The paper therefore treats metric grounding as a prerequisite for reliable obstacle avoidance, exploration, and policy assessment.

The normalization pipeline described in the paper makes the missing quantity precise. After division by $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$5, the trajectory is converted into a delta sequence and normalized to $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$6. At inference, the delta normalization and integration can be reversed, but the initial multiplication by $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$7 cannot be recovered from the policy output alone. MetricNet is introduced to supply that missing factor.

3. MetricNet as the enabling scale regressor

MetricNet is the add-on module that recovers metric scale from the policy output and current observation. Its inputs are the unscaled trajectory $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$8 and the current observation $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$9, and its output is a scalar scale prediction $\mathbf{g}_i$0, interpreted as the metric distance between waypoints. The normalized trajectory is then projected into metric space using this predicted scale (Nayak et al., 17 Sep 2025).

The model is trained as a regression network with supervision from $\mathbf{g}_i$1. Its loss is a scaled mean squared error,

$\mathbf{g}_i$2

with $\mathbf{g}_i$3 so that, in the paper’s description, the loss is scaled to millimeters to avoid gradient collapse. The training corpus combines real-world data from GoStanford, RECON, TartanDrive, SACSoN, and SCAND with synthetic Habitat data generated from $\mathbf{g}_i$4 Matterport3D indoor scenes and $\mathbf{g}_i$5k trajectories. To diversify scale targets, the authors subsample trajectory segments by skipping varying numbers of waypoints: $\mathbf{g}_i$6 in indoor real datasets, up to $\mathbf{g}_i$7 in outdoor datasets, and $\mathbf{g}_i$8 in synthetic trajectories. The total training set contains about $\mathbf{g}_i$9 million data points.

Architecturally, MetricNet fuses waypoint, RGB, and depth information. The unscaled trajectory is encoded by a $\pi$0D convolutional network,

$\pi$1

The current observation is split into $\pi$2 patches and encoded with EfficientNet-B0,

$\pi$3

then projected to dimension $\pi$4 by a residual network. Depth information is extracted using the pre-trained DINOv2 encoder from Depth-Anything-V2, producing tokens

$\pi$5

with patch size $\pi$6; these tokens pass through a single-block residual network because the DINOv2 encoder is frozen. Fusion is performed by a transformer encoder with a prepended classifier token, described as “a small transformer of six heads with three attention layers,” yielding

$\pi$7

followed by an MLP head

$\pi$8

Training is reported as $\pi$9 epochs on an NVIDIA H200 GPU with batch size $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$0, AdamW, initial learning rate $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$1, and a cosine scheduler. The paper’s characterization of MetricNet is therefore narrow and specific: it is a supervised metric-scale regressor, not a navigation policy.

4. MetricNav execution and position control

MetricNav uses MetricNet’s scale prediction to alter how policy outputs are executed. The basic pipeline is: a generative navigation policy samples one or more trajectories in normalized waypoint space; MetricNet predicts $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$2 and converts them to metric coordinates; the robot then executes the full segment of waypoints from the current position up to waypoint $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$3. The paper terms this position control, in contrast to velocity control’s single-waypoint tracking (Nayak et al., 17 Sep 2025).

This change is conceptually significant because it causes the robot to follow the shape of the predicted path rather than shortcut directly to one target. The horizon is not executed all the way to $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$4 in a single step. Instead, the robot follows only the segment up to $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$5, then observes again and replans. The paper states that this is done because the scene may change or distant obstacles may be occluded. MetricNav is therefore iterative: generate a trajectory, scale it, execute a partial segment, observe again, and replan.

On the real robot, the paper implements a rotate–translate strategy for metric waypoints: rotate at $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$6 for $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$7 seconds, then translate at $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$8 for $$A_i=\pi(\mathbf{o}_i,\mathbf{g}_i), \qquad A_i=[\mathbf{a}_i:\mathbf{a}_{i+T_A}],$$9 seconds. The authors explicitly avoid adding reactive classical controllers such as DWA in order to keep comparisons fair. A plausible implication is that the reported gains are intended to isolate the effect of metric grounding and path execution rather than hybridization with conventional local planning.

The paper’s comparison settings use a common prediction horizon $\mathbf{a}_t$0. Both position and velocity control use $\mathbf{a}_t$1, except for one fair-comparison setting for MetricNav velocity control where $\mathbf{a}_t$2. This reinforces the paper’s broader claim that the main intervention is not retraining the base policy, but replacing single-waypoint tracking with rescaled path execution.

5. Metric-space guidance during diffusion sampling

MetricNav also adds a guidance mechanism during diffusion sampling. The framework samples $\mathbf{a}_t$3 trajectories from the base policy, applies spherical k-means to the directions of the $\mathbf{a}_t$4-th waypoint to estimate the dominant goal-directed action, and then guides a second sampling loop with collision and goal costs (Nayak et al., 17 Sep 2025).

The collision term depends on metric grounding. A monocular metric depth estimator, Depth-Anything-V2 with ViT-B, produces a depth image that is converted using approximate camera intrinsics into an egocentric point cloud. Ground plane segmentation via RANSAC separates free space from obstacle points, and these populate a local TSDF. The paper distinguishes this TSDF from prior formulations by assigning nonzero values in both obstacle and free space so that trajectories lying in free space can still receive gradients away from nearby obstacles. The collision cost is

$\mathbf{a}_t$5

where the left and right offsets represent robot body boundaries, so clearance is evaluated for the footprint rather than only the centerline.

The goal term penalizes angular deviation from the chosen goal direction at the $\mathbf{a}_t$6-th waypoint. The total guidance objective is

$\mathbf{a}_t$7

and the denoising step is modified by subtracting a gradient term,

$\mathbf{a}_t$8

The authors apply this guidance only for $\mathbf{a}_t$9, that is, in late denoising steps, with tuned parameters $2$0, $2$1, and $2$2.

After guidance, final action selection combines a goal similarity score $2$3 and a collision score $2$4 through

$2$5

The paper’s qualitative interpretation of $2$6 is explicit: $2$7 remains close to the goal trajectory, $2$8 prioritizes moving to a safe state, and $2$9 balances progress and safety.

6. Evaluation, results, and comparative behavior

The simulation benchmark is designed specifically to stress current generative navigation policies. It uses Habitat with $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$0 topological maps in $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$1 different environments, each with trajectories of minimum length $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$2 m. Agents are spawned at the first position of each map and evaluated with the same seeds across methods. The study uses $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$3 different seeds, yielding $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$4 repetitions per baseline, and collision checking uses TurtleBot4 dimensions. The benchmark is described as intentionally hard because it includes tight curves and shortest-path topological maps that force robots to move near walls (Nayak et al., 17 Sep 2025).

The primary comparisons involve plain generative navigation with fixed scale and velocity control, the same policies with MetricNet scaling and position control, and the full MetricNav framework with guidance. All baselines—NoMaD, FlowNav, and NaviDiffusor—are retrained on the same data split for fairness. Figure 1, as described in the text, shows that replacing the constant $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$5 scale with MetricNet’s predicted metric scale improves both navigation and exploration for NoMaD, FlowNav, and NaviDiffusor, and that position control outperforms velocity control when using MetricNet.

In the main simulation navigation table, the average fraction of the topomap completed under velocity control is $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$6 for NoMaD, $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$7 for FlowNav, $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$8 for NaviDiffusor, and $$\phi_\text{gt} = \sum_{k=0}^{T_A-1}\frac{\lVert\mathbf{a}_{i+(k+1)}-\mathbf{a}_{i+k}\rVert_2}{T_A -1},$$9 for MetricNav. Under position control, the corresponding values are $\tilde{A}_i = A_i / \phi_\text{gt}.$0, $\tilde{A}_i = A_i / \phi_\text{gt}.$1, $\tilde{A}_i = A_i / \phi_\text{gt}.$2, and $\tilde{A}_i = A_i / \phi_\text{gt}.$3. The paper interprets these numbers in a specific way: MetricNav’s guidance is most clearly beneficial when the execution mode itself is weak, whereas once metric scaling and path-following position control are already in place, guidance makes MetricNav comparable to the best baselines rather than dramatically superior.

Real-world validation is performed on a TurtleBot4 with ROS2 Humble, a fisheye camera at $\tilde{A}_i = A_i / \phi_\text{gt}.$4 Hz, and an NVIDIA RTX A500 laptop GPU. The test course is a long corridor with several turns and obstacles at both corners and straight segments. Each model is tested for $\tilde{A}_i = A_i / \phi_\text{gt}.$5 runs, and a trial terminates on frontal collision or if the robot cannot recover within $\tilde{A}_i = A_i / \phi_\text{gt}.$6 s. The reported success rate and average number of collisions per run are: NoMaD with velocity control, SR $\tilde{A}_i = A_i / \phi_\text{gt}.$7, collisions $\tilde{A}_i = A_i / \phi_\text{gt}.$8; NoMaD with position control, SR $\tilde{A}_i = A_i / \phi_\text{gt}.$9, collisions $\phi_\text{gt}$0; FlowNav with velocity control, SR $\phi_\text{gt}$1, collisions $\phi_\text{gt}$2; FlowNav with position control, SR $\phi_\text{gt}$3, collisions $\phi_\text{gt}$4; NaviDiffusor with velocity control, SR $\phi_\text{gt}$5, collisions $\phi_\text{gt}$6; NaviDiffusor with position control, SR $\phi_\text{gt}$7, collisions $\phi_\text{gt}$8; and MetricNav with position control, SR $\phi_\text{gt}$9, collisions $\mathcal{O}_i=[\mathbf{o}_{i}:\mathbf{o}_{i-T_O}]$00. These are the highest reported real-world success rate and the fewest collisions in the paper.

The qualitative evidence is aligned with these results. The paper repeatedly shows cases in which a trajectory that is safe in metric space becomes unsafe when only its endpoint is tracked, and cases in which unguided trajectories collide whereas guided and scaled trajectories remain in free space.

7. Limitations, interpretation, and significance

Several limitations are identified directly in the paper. MetricNav’s strongest gains appear in velocity control and in real-world collision reduction; under position control in simulation it is comparable to the strongest baselines rather than clearly better. Metric prediction accuracy is not reported with a standalone regression table, so support for MetricNet is primarily indirect, through navigation and exploration improvements (Nayak et al., 17 Sep 2025).

The method also depends on monocular metric depth, approximate camera intrinsics, and a local TSDF. If depth is inaccurate or obstacles are poorly observed, the guidance mechanism may be imperfect. The paper further notes that the controller is not reactive to dynamic obstacles and suggests future integration with reactive control such as DWA. An additional engineering constraint is runtime: because inference on the real robot is performed on a laptop GPU, MetricNav is described as less suited to velocity control.

Two interpretive points are especially important. First, the results indicate that a substantial share of the empirical gain comes from metric grounding and full-path execution, not only from diffusion guidance. Second, the framework does not alter the training of the underlying generative policy; it changes deployment by recovering scale, following a path segment, and optionally applying metric-space guidance. This suggests that MetricNav is best understood as a deployment framework for generative navigation rather than as a replacement for generative navigation.

In the paper’s final synthesis, recovering metric scale is presented as more than a calibration detail. The broader claim is that metric scale is what makes the predicted trajectory executable as a real path. On that reading, MetricNav’s significance lies in converting abstract waypoint sequences into metrically grounded path segments that can be executed, evaluated, and guided in relation to real obstacles and free space.