Aim My Robot: Precision Local Navigation to Any Object

In plain words

Most robot navigation stops when the robot is about a metre from its goal. That is fine for finding a room, but not for parking a forklift in front of a pallet, docking a robot, or standing square to a fridge so it can be opened.

Aim My Robot (AMR) is a system for that last stretch. You show it a picture of the target object with the object outlined. You also say which side of the object to face, how far away to stand, and at what angle. The robot then moves there using its camera and a 2D laser scanner, without a map and without a 3D model of the object. The camera head also tilts to keep the object in view.

The model was trained on a large set of simulated trajectories in photorealistic indoor scenes. The trajectories were planned by an algorithm, not recorded from a human driving the robot §III-A. The authors report that it works on a real robot and on objects it never saw in training.

TL;DR

• AMR is a vision-based local navigation model. It reaches a goal pose relative to an object, not just a point within a metre §I §II.
• The goal is a reference image with object mask, an approach side, a distance and an angle §II.
• It fuses RGB-D, LiDAR and goal tokens in a transformer, and predicts base waypoints and camera tilt §III-B.
• Trained on 500k simulated trajectories in Isaac Sim, with DAgger §IV.
• Author-reported: 3 cm and 1 degree median error on unseen objects in simulation, and little loss on a real robot §I.

Problem

Navigation systems usually count a goal as reached within about 1 m §I. The authors need a robot to stop at a precise relative pose to an object, for docking, inspection or manipulation §I §II, such as a forklift lining up with a pallet §V-D.

They assume the robot is already within about 10 m of the object, around room size, and that some other system supplies the goal §II. The robot has no object CAD model and no 2D or 3D map. Classical pose estimation needs the object model and a visible object §I §VI.

The goal is G = \{I_R, M, \mathbf{C}\}: reference image, object mask and relative pose \mathbf{C} = \{S, d, \theta\} §II, unnumbered equation. The side S is one of front, back, left or right. Front is the most visible side of the object in I_R §II.

Method

AMR is trained with behaviour cloning on data from a simulator, then refined with DAgger §IV. The data pipeline and the model are described in §III.

Data generation §III-A. The authors import Habitat Synthetic Scenes (HSSD) into Isaac Sim, which renders photorealistic images with ray tracing. Each training sample draws:

1. a robot footprint radius, a cylinder placed at random in the traversable area of a room §III-A;
2. a reference image, rendered either from the robot's start view or from a random view, with a target object mask taken from the simulator §III-A;
3. a goal side, distance and angle, after which the robot is placed at the goal and checked for collisions §III-A.

A path is planned with AIT* in a Reeds-Shepp state space with turning radius 0, which fits a differential-drive base. The cost prefers a camera that looks toward the goal and penalises backward motion §III-A. Along each path the camera is rendered every 0.2 m or every 5 degrees §III-A. The tilt is set so that the lowest vertex of the object mesh sits a quarter of the way up from the bottom of the image §III-A.

Model §III-B. The model has three stages, shown in fig. 5.

1. Sensor encoding §III-B1. The current RGB image goes through a frozen MAE-Base encoder, giving a grid of patch tokens. Depth is not concatenated. It is turned into a 3D position for each depth patch, which is encoded with sinusoidal embeddings and added to the matching RGB token. Past frames are handled the same way; their extrinsics are the camera-to-base transform from odometry §III-B1. LiDAR points are grouped into 32 directional bins, and an MLP turns each bin into one token.
2. Goal-aware, robot-aware fusion §III-B2. The reference image goes through the same frozen MAE. The mask goes through a small convolutional network. A vision context encoder \mathcal{F} handles the image tokens, and a mask decoder \mathcal{G} reads its output to predict masks, which helps it track the target. Goal values (d, \theta, S) and the footprint radius R each get their own MLP. A multi-modal context encoder \mathcal{H} then takes all the tokens.
3. Motion generation §III-B3. The output of \mathcal{H} is cross-attended by two decoders. One predicts the base trajectory, an autoregressive transformer that outputs waypoints in egocentric polar coordinates. The other predicts camera tilt. The base is replanned every 8 steps, and the tilt is updated at every step §IV.

Each waypoint is a triple: direction, distance and heading. These are sampled one after another, each as a classification over bins plus a residual correction predicted by a small MLP §III-B3. The base is replanned with a receding horizon §III-B3.

# AMR inference, one control step  [§III-B] [§IV]
# Input:  goal (reference image, mask, side, distance, angle, footprint),
#         current RGB-D frame and LiDAR scan
# Output: base waypoints (replanned every 8 steps), camera tilt (every step)

def control_step(goal, frame, lidar):
    # Tokenize the reference image with the frozen MAE  [§III-B2]
    goal_image_tokens = frozen_mae(goal.image)           # same shape as RGB
    # Encode the mask with a small convolutional network  [§III-B2]
    mask_tokens = mask_encoder(goal.mask)                # shape not stated
    # Tokenize the current RGB with the frozen MAE  [§III-B1]
    rgb_tokens = frozen_mae(frame.rgb)                   # (196, 512)
    # Add the depth position embedding to each RGB patch  [§III-B1]
    rgb_tokens = rgb_tokens + depth_position_embedding(frame.depth,
                                                       frame.extrinsics)
    # One token per directional LiDAR bin, 32 in total  [§III-B1]
    lidar_tokens = lidar_bin_mlp(bin_lidar_points(lidar, bins=32))
    # Separate MLPs for the goal values and the footprint  [§III-B2]
    goal_token = goal_mlp(goal.side, goal.distance, goal.angle)
    footprint_token = footprint_mlp(goal.footprint)
    # Vision context encoder F, then multi-modal context encoder H  [§III-B2]
    vision_context = vision_encoder(goal_image_tokens, mask_tokens,
                                    rgb_tokens)
    context = multimodal_encoder(vision_context, lidar_tokens,
                                 goal_token, footprint_token)
    # Predict the camera tilt, a regression output  [§III-B3]
    tilt = tilt_decoder(context)
    # Decode waypoints one at a time, T = 12 in total  [§III-B3] [§IV]
    waypoints = autoregressive_decode(context, num_waypoints=12)
    return waypoints, tilt

The training loss, from §IV, is a plain sum of three terms:

# Training loss  [§IV]
# Input:  predicted and target masks (all history frames), waypoints, tilt

def training_loss(predicted, target):
    # Pixel-wise L2 on the object mask over all history frames  [§IV]
    mask_loss = l2(predicted.masks, target.masks)
    # Classification and regression per waypoint, as in BeT  [§IV]
    base_loss = waypoint_classification(predicted.waypoints, target.waypoints)
    base_loss = base_loss + waypoint_regression(predicted.waypoints,
                                                target.waypoints)
    # L2 on the camera tilt angle  [§IV]
    tilt_loss = l2(predicted.tilt, target.tilt)
    return mask_loss + base_loss + tilt_loss

Here waypoint_classification and waypoint_regression are the names of the two parts of the base loss. The paper gives no loss formulas for them, so this is a reading of "classification loss and regression loss for each waypoint" in §IV.

Hyperparameters

Results

Author-reported. Setup: HSSD simulation with 2,000 navigation tasks in five unseen scenes §IV; a real kitchen and a simulated forklift §V-C §V-D. The baseline is FoundationPose pose estimation with a CAD model, a ground-truth occupancy map and the same planner §V-A. The baseline therefore uses information AMR does not use: a CAD model, a visible object at the start, and a perfect map §V-A.

Full data from the paper:

Table I tab. I. Median angular error (MAE, degrees) and median distance error (MDE, m) for seen and unseen instances in the test scenes.

Seen column: 136 unique objects. Unseen column: 166 unique objects tab. I.

Table II tab. II. Collision rate of ablated models. Units are not stated.

Table III tab. III. Real kitchen. Each cell is completed runs out of 3, the distance error in cm, and the orientation error in degrees. The paper does not say whether the errors average only over completed runs.

Other figures: fig. 6 error distributions by object distance, with the completion rates above; fig. 7 qualitative runs and failure cases; fig. 8 ablation error distributions over all runs, complete and incomplete; fig. 9 and fig. 10 real-world runs; fig. 11 a fridge drawer closed by the robot body and a forklift loading a pallet.

Paper vs code

No official code.

I searched in this order. The arXiv abstract page and the paper's project page (sites.google.com/view/aimmyrobot, linked from the abstract) contain no code link. GitHub search found no repository for "aimmyrobot", "aim-my-robot" or "aim my robot", and none in the NVlabs organisation. The GitHub account of author Xuning Yang (xuningy) has no repository that matches the method. The only aimmyrobot account is an unrelated profile-config repo.

Pitfalls

• Goal distance range conflicts. The task defines d in [0.0, 1.0] m §II. Training samples d in [0.1, 0.5] m §III-A. The real kitchen and forklift experiments use d = 1 m and 2 m §V-C §V-D. Both are outside the training range. The paper does not explain how well the model generalises to them.
• Object counts conflict. §IV gives 160 unseen objects among 275 test objects. tab. I gives 136 seen and 166 unseen unique objects.
• Inference rate conflicts. §IV says 12 Hz on an RTX 3090. The conclusion says 10 Hz §VII.
• Loss weights. The three loss terms are summed with weight 1 each §IV. The optimiser, learning rate and schedule are not stated, so training cannot be reproduced from the paper alone.
• Unstated architecture. Layer counts, widths, heads and the mask decoder are not stated. The sinusoidal embedding frequencies are not stated either. Depth is resized to 14 × 14, but how depth values are pooled per patch is not stated. Neither is how LiDAR points are resampled to 256.
• Bin-to-value mapping. The waypoint value is a classifier output plus a residual §III-B3. The paper does not say what value each bin represents, so the bin centres are a guess.
• Success is a 1 m test; precision is measured on completed runs only. Errors in tab. I and the centimetre headline come from runs that finished within 1.0 m §V. Completion rate is reported separately §V fig. 6.
• Real-world ground truth limits precision. Real errors are measured against an occupancy map at 2 cm resolution §V, and some real-world figures are hand-measured tab. III. The 2 cm resolution is the same order as the errors reported, so the centimetre claims need care.
• Baseline is not like-for-like. The baseline is given a CAD model, a visible object and a perfect map §V-A. AMR gets none of these, so the gap does not isolate the method.
• History differs by setting. History frames are 0 in simulation and 4 on the real robot §IV. The paper reports no noticeable benefit from history in simulation §IV, but says history is critical on the real robot §V-C.
• Forklift is simulated only. The forklift result uses a simulated forklift with about 500 fine-tuning demonstrations §V-D. The real-world forklift is not tested.
• Replanning versus horizon. Trajectories have 12 waypoints but replanning happens every 8 steps §IV. The receding-horizon description says "up to T" §III-B3. How the replan interval interacts with the horizon is not described.
• Ablation units. The units of tab. II are not stated.
• Section and table numbering. Section numbers here follow IEEEtran's convention in the source: roman numerals for sections, capital letters for subsections and arabic numbers with ")" for subsubsections. The compiled PDF shows these labels. Figure and table numbers follow order of appearance in the source.
• Equations are unnumbered. The loss and goal definition are display equations without numbers. They are cited as §IV and §II.
• Cost. Training needs Isaac Sim, HSSD scenes and 150k steps on 8 A100 GPUs §IV.

Lineage

• Builds on: Masked Autoencoders, MAE-Base, frozen as the image encoder §III-B1; a small convolutional mask encoder similar to SAM §III-B2; Behavior Transformer for the per-waypoint classification and regression loss §IV; DAgger for data augmentation after behaviour cloning §IV; AIT* for path planning in data generation §III-A.
• Compared against: a pose-estimation baseline with FoundationPose, a CAD model and an occupancy-map planner §V-A. Ablation against an ACT-style decoder §V-B and a model with no mask decoder tab. II.
• Superseded by: none known from this wiki.