Pith. sign in

REVIEW 5 major objections 6 minor 34 references

AutoLoop: Fast Visual SLAM Fine-tuning through Agentic Curriculum Learning

T0 review · 5 major / 6 minor · reviewed 2026-08-10 · deepseek-v4-flash

Challenge this review Re-run · record.json Download PDF Read on arXiv ↗ Review JSON

Pith's one-line read AutoLoop adds loop-closure awareness to the DPVO visual odometry model through automated fine-tuning, reducing training time from 96 hours to 8 hours while matching or improving trajectory accuracy on outdoor benchmarks.

desk verdict Useful fine-tuning recipe for loop-closure-aware DPVO, but the claimed DDPG curriculum advantage is untested and the 10x speedup is against the wrong baseline. read the letter →

arxiv 2501.09160 v1 pith:CYUIPYHG submitted 2025-01-15 cs.RO cs.AIcs.LG

Assaf Lahiany , Oren Gal This is my paper · ORCID
classification cs.ROcs.AIcs.LG
keywords visualSLAMloopclosurecurriculumlearningDDPGagentfine-tuningDPVOodometryTartanAir
verification ladder T0 review T1 audit T2 compute T3 formal

The pith

A machine-rendered reading of the paper's core claim, the machinery that carries it, and where it could break.

The reading

AutoLoop claims that a learned visual odometry model can gain loop-closure awareness through a short, automated fine-tuning step instead of full retraining or architectural surgery. The method appends a loop-closure loss to the DPVO model, pre-computes verified loop-closure pairs offline from TartanAir, and lets a DDPG reinforcement-learning agent set the loss weight during training. On KITTI and TartanAir the fine-tuned model matches or beats the base VO and several SLAM baselines while keeping DPVO's real-time inference speed. The headline result is cost: 3,360 training steps (roughly 8 hours on one V100 GPU) replace the 32,000 steps (96 hours) needed to train DPVO from scratch, a tenfold compute reduction. Indoor benchmarks (EuRoC, TUM) transfer poorly, a limitation the paper attributes to the outdoor character of its pre-computed training pairs.

What carries the argument

The load-bearing machinery is the agent-guided curriculum over a single scalar: the loop-closure weight $w_{loop}$ in the fine-tuning objective. A DDPG agent, with state $(p_i, L^{ema}_i)$ (training progress and an exponentially smoothed loop-loss), outputs an action $a_i$ that interpolates $w_{loop}$ between an initial and a final value, with reward equal to the negative smoothed loop loss. This replaces manual scheduling of when loop-closure constraints should dominate. Around it sits an offline database of geometrically verified loop-closure pairs (NetVLAD-style retrieval plus SIFT/epipolar verification) that supplies the supervision signal, and a Huber loss $h_\delta$ over relative pose errors inside $L_{loop}$ that keeps the signal stable against noisy or hard pairs.

What would settle it

Run the same fine-tuning with $w_{loop}$ fixed at 0.62 for all 3,360 steps and compare the final ATE and loss curve against the DDPG-guided run; if the fixed-weight run matches AutoLoop's KITTI and TartanAir numbers, then the agentic curriculum is not the cause of the speedup and the claimed contribution narrows to loop-closure fine-tuning.

Watch

Extended reading notes

Core claim

The paper's central discovery is that loop-closure supervision can be folded into an already-trained visual odometry network as a fine-tuning signal, and that an automated curriculum can schedule that signal cheaply. Using an offline pipeline (EfficientNet-VLAD retrieval plus geometric verification) the authors harvest 551 verified loop-closure pairs from 337 TartanAir scenes. They then fine-tune DPVO with a composite loss $L_{total} = s_f L_{flow} + s_p L_{pose} + w_{loop} L_{loop}$, where $L_{loop}$ is a Huber-weighted relative-pose error against the pre-computed pairs, and a DDPG agent continuously adjusts $w_{loop}$ from a conservative start to a converged value near 0.62. With only 3,360 steps (41.9 PFLOPs, about 8 hours on a V100) the model reaches ATE comparable to or better than the base DPVO on KITTI and TartanAir, while slower SLAM pipelines that actually optimize loop closures win on indoor sets.

Load-bearing premise

The paper assumes, without testing, that the DDPG agent's adaptive weight schedule, and not the final converged weight of 0.62 or a simple constant, is what makes fine-tuning converge in 3,360 steps.

Editorial extensions

If this is right

  • A learned VO model can gain loop-closure awareness through fine-tuning alone, without architectural changes, so the enhancement transfers to any system built on DPVO.
  • Because inference is unchanged, the fine-tuned model runs at DPVO's real-time speed (48 FPS on KITTI) instead of the slower SLAM variants that incur more memory and roughly 19% FPS loss.
  • The training budget drops from 96 hours and 399 PFLOPs to 8 hours and 41.9 PFLOPs, making loop-closure-aware SLAM fine-tuning feasible on a single GPU in one workday.
  • Outdoor benchmarks (KITTI, TartanAir) support the method's efficiency claim, while indoor benchmarks (EuRoC, TUM) indicate that generalization is limited to environments resembling the training distribution.

Reading between the lines

Editorial extensions of the paper, not claims the author makes directly.

  • The DDPG agent is never ablated against a fixed or manually scheduled loop weight, so a head-to-head with $w_{loop}$ held at the converged value 0.62 from the first step would be the decisive check on whether the 'agentic curriculum' is what buys the 10x speedup.
  • The offline pair database suggests an operational pattern the paper only hints at: a robot pre-scans an environment once, builds the loop-closure database in 15-20 minutes, fine-tunes overnight on a single GPU, and then runs with real-time VO speed on future visits.
  • Because indoor sets (EuRoC, TUM) fail to show loop-closure gains, a testable extension is to add indoor sequences to the offline database and re-run the exact same pipeline; if indoor ATE then improves, the gap is a data-coverage problem rather than a curriculum problem.
  • The converged weight of roughly 0.62 and the short exploration phase together imply that a simple ramp schedule might reproduce the same loss curve, which would make the RL agent unnecessary for the reported speedup.
Share X Bluesky LinkedIn Reddit HN

Editorial analysis

A structured set of objections, weighed in public.

Desk editor's note, referee report, and a circularity audit.

Referee Report

5 major / 6 minor

Summary. The paper proposes AutoLoop, a method that adds loop closure awareness to the DPVO visual odometry model by fine-tuning with precomputed loop closure pairs while a DDPG-based curriculum agent adjusts the loop closure loss weight during training. The offline pipeline uses EfficientNet-VLAD descriptors and SIFT geometric verification on TartanAir to build a database of 551 loop pairs; fine-tuning then runs for only 3,360 steps. The authors report ATE results on KITTI, TartanAir test, EuRoC MAV, TUM-RGBD, and ICL-NUIM, with improvements over DPVO on KITTI and ICL-NUIM, comparable results on TartanAir, and weaker results on EuRoC and TUM-RGBD, while preserving DPVO's inference speed. The central claim is that AutoLoop achieves comparable or superior performance while reducing training time by an order of magnitude relative to from-scratch training of DPVO and CL-DPVO.

Significance. If the central claims were fully supported, the paper would offer a practically useful recipe for adapting learning-based VO models to new domains with loop closure supervision at a fraction of the usual training cost. The precomputation pipeline is a sensible way to avoid online loop detection overhead, and the evaluation on multiple external benchmarks is a strength. The paper also explicitly acknowledges its limitations on indoor datasets, which is honest and useful. However, the key causal claim that the DDPG agent's curriculum is what enables fast convergence is not tested, and the order-of-magnitude speedup claim compares fine-tuning against from-scratch training, which is not an apples-to-apples baseline.

major comments (5)
  1. [§III-E, Table VI, Fig. 3] The central claim that the DDPG-based curriculum enables convergence in 3,360 steps is not isolated by any ablation. Figure 3 shows that the learned weight converges to 0.62 by approximately step 420 and remains effectively constant for the remaining ~2,940 of 3,360 steps; the only comparisons in Table VI are against DPVO and CL-DPVO trained from scratch for 32K and 42K steps. No run is reported for DPVO fine-tuned for the same 3,360 steps with the same loop pairs and a fixed wloop (e.g., 0.62), nor for a manually scheduled weight, nor for fine-tuning without the loop loss. Without such baselines, the reported speedup may be entirely due to starting from a pretrained checkpoint and to the loop closure loss itself, rather than to the learned curriculum. This is load-bearing for the 'agentic curriculum' contribution and should be addressed with the missing experiments.
  2. [§I and §III-E] The claim that the method 'eliminates the need for manual hyperparameter search' is overstated. The method still requires manual selection of w0 and wF in Eq. (5), the state and reward definitions in Eq. (7), the exploration schedule in Eq. (8), the DDPG agent hyperparameters (learning rates, network widths, replay buffer size), the Huber delta in Eq. (4), and the loop detection thresholds in §IV-A. The contribution should be framed as replacing one set of manually chosen weights with another set of meta-parameters, or the authors should provide a sensitivity study demonstrating robustness to these choices.
  3. [§IV-C, Tables III and IV] The abstract's claim of 'comparable or superior performance' is not supported across the full benchmark suite. On EuRoC MAV, AutoLoop's average ATE (0.097) is worse than CL-DPVO (0.091) and much worse than DPV-SLAM++ (0.023); on TUM-RGBD, AutoLoop (0.094) is worse than both DPVO (0.089) and CL-DPVO (0.079). The paper acknowledges poor indoor generalization in the conclusion, but the summary claims should be restricted to the datasets where the improvement is consistent (KITTI and ICL-NUIM) or the abstract and introduction should be revised to reflect the mixed results.
  4. [§IV-C, experimental protocol] The paper states that each experiment is run five times and the median is reported, but no variance information is provided anywhere. Several performance differences are small (e.g., EuRoC average ATE 0.097 vs. 0.091 for CL-DPVO; KITTI sequence 00 111.11 vs. 113.21 for DPVO), so without standard deviations, confidence intervals, or per-run values, it is impossible to judge whether the reported differences are statistically meaningful. Please report spread measures for the median results, especially for the comparisons that support the main claims.
  5. [§III-D, Eq. (3)] The loop closure loss definition is ambiguous. The double sum over i and j, combined with the statement that N is the total number of valid loop closure pairs, suggests that each pair may be counted multiple times or that the indexing is inconsistent. Please clarify whether the sum is over the set of precomputed loop pairs (i, j) or over all combinations, and define N accordingly. This matters because the loss normalization directly affects the gradient scale during fine-tuning.
minor comments (6)
  1. [Throughout] There are numerous typos and grammatical errors, including 'avarage' (Table I caption), 'sucrifice' (§IV-C KITTI), 'generelaize' (§IV-C EuRoC), 'autonmous' (§III-F), 'convergance' (§IV-B), 'elimenates' (§IV-D), 'fotprint' (§IV-D Inference), and inconsistent capitalization of 'Huber'.
  2. [Eq. (4)] The Huber loss parameter delta is left unspecified. Please provide the value used in the experiments, since it controls the balance between quadratic and linear gradient behavior.
  3. [References] Reference [15] cites a paper on LoRa wireless technology, not the Low-Rank Adaptation method for neural network fine-tuning commonly referred to as LoRA. Please replace it with the correct reference (Hu et al., 2021, 'LoRA: Low-Rank Adaptation of Large Language Models').
  4. [§IV-A] The pre-computation overhead section reports 9.4e9 total FLOPs for a 2000-frame sequence and estimates 15–20 minutes on a V100; this FLOP count is tiny compared to the reported throughput of such a GPU, so the time estimate likely includes feature extraction, matching, and geometric verification overhead. Please clarify what the time estimate actually covers.
  5. [Figure 3] Figure 3 would be more informative with labeled axes, a vertical line marking the end of the exploration stage (step 200), and a horizontal line at the converged value 0.62, so that the reader can see the proportion of training that uses a fixed weight.
  6. [§IV-B] The DDPG agent description gives only a few hyperparameters (three-layer actor/critic with max width 64, update every 30 steps, batch size 64, replay buffer 5k). Missing values such as learning rates, discount factor, target network update rate, and exploration noise parameters make the method difficult to reproduce; please provide a full hyperparameter table.

Circularity Check

1 steps flagged · score 2.0 of 10

Minor self-reference in the DDPG reward; central performance claim remains externally grounded by ATE benchmarks.

  1. self definitional [Section III-E, Eqs. (5)-(7), and Figure 3]
    "wloop i = w0 + (wF − w0)ai (5) ... si = [pi, Lema i ]; ri = −Lema i (7) ... the reward ri is simply the negative of the smoothed loss. This setup allows the agent to adaptively adjust curriculum weights based on both the training progress and current performance, effectively learning an optimal progression path that minimizes loop closure loss during training."

    The DDPG action ai directly sets the loop closure weight wloop through Eq. (5), and the reward is the negative smoothed loop loss, which is the very loss term scaled by that same weight. The agent can therefore reduce its reward signal simply by lowering wloop, so the claimed 'optimal progression path' is not independently evidenced: the learned schedule is rewarded for shrinking a quantity it directly controls. This is a self-referential training objective rather than an external validation of the curriculum. The paper's headline performance comparisons are still grounded by test-time ATE on independent benchmarks, so this does not collapse the central empirical claim.

full rationale

The paper's main quantitative claims are evaluated against external benchmarks (KITTI, EuRoC, TUM, ICL-NUIM, and the TartanAir test split), so the order-of-magnitude speedup and comparable-or-better ATE are not derived from the fitted training loss. The only identifiable self-reference is internal to the DDPG agent: its reward is the negative smoothed loop loss whose weight the agent itself sets, so the assertion that the agent learns an optimal curriculum is partly circular. Additionally, the 3,360-step fine-tuning comparison is made against 32K from-scratch training, and no fixed-weight fine-tuning baseline is reported, leaving the causal contribution of the DDPG schedule untested. These are methodological gaps and a minor self-reference, not a derivation that reduces to its inputs; the external ATE results keep the central performance claim independent. Hence a low score of 2 is appropriate.

Assumptions & free parameters 4 free parameters · 4 assumptions · 0 invented entities

The central claim rests on several hand-chosen detection thresholds, an unspecified Huber delta, unreported DDPG hyperparameters, and the domain assumption that offline loop pairs are trustworthy ground truth. No new physical or architectural entities are introduced; the 'agent' is a standard DDPG policy.

free parameters (4)
  • Loop weight interpolation bounds w0 and wF = w0 ~ 0.1-0.2, wF converges to 0.62
    Chosen by hand to define the action-to-weight mapping in Eq. (5); the converged value appears in Figure 3.
  • Loop closure detection thresholds (similarity, inliers, clusters, buffer) = 0.75, 30, 32, 2000
    These parameters set the precomputed loop pair database (551 pairs on TartanAir) that serves as supervision in Eq. (3).
  • Huber delta in Eq. (4) = Not reported
    Controls the transition from quadratic to linear gradient scaling in the loop loss; no value is given.
  • DDPG agent hyperparameters (learning rates, network widths, exploration noise) = Not reported
    The agent behavior depends on these, but only the actor/critic width (64) and update frequency (every 30 steps) are mentioned.
assumptions (4)
  • domain assumption Precomputed loop closure pairs from the offline NetVLAD-SIFT pipeline are correct enough to serve as ground truth Ggt,j in Eq. (3).
    The loop loss penalizes deviation from these pairs; if they are wrong, the model is trained toward incorrect geometry.
  • domain assumption DPVO's loss scaling sp=10 and sf=0.1 (from prior work [3]) remain appropriate during fine-tuning with the additional loop loss.
    Eq. (2) keeps these scales without re-derivation; a different balance might change results.
  • standard math SE(3) Lie-group logarithm and Huber loss have the standard mathematical properties assumed in Eq. (3)-(4).
    Used to define the loop closure error; not proved in the paper.
  • domain assumption TartanAir sequences with detected loop closures provide sufficient and representative supervision for transfer to KITTI, EuRoC, TUM, and ICL-NUIM.
    The method trains only on TartanAir loops; the authors note limited transfer to indoor datasets, making this assumption partly violated.

how reviews work

0 comments
Cite this review

Pith. "Pith review of AutoLoop: Fast Visual SLAM Fine-tuning through Agentic Curriculum Learning." pith.science (2026). https://pith.science/paper/CYUIPYHG

@misc{pith2026250109160,
  author       = {Pith},
  title        = {Pith review of: AutoLoop: Fast Visual SLAM Fine-tuning through Agentic Curriculum Learning},
  year         = {2026},
  howpublished = {\url{https://pith.science/paper/CYUIPYHG}},
  note         = {Machine review of arXiv:2501.09160}
}
read the original abstract

Current visual SLAM systems face significant challenges in balancing computational efficiency with robust loop closure handling. Traditional approaches require careful manual tuning and incur substantial computational overhead, while learning-based methods either lack explicit loop closure capabilities or implement them through computationally expensive methods. We present AutoLoop, a novel approach that combines automated curriculum learning with efficient fine-tuning for visual SLAM systems. Our method employs a DDPG (Deep Deterministic Policy Gradient) agent to dynamically adjust loop closure weights during training, eliminating the need for manual hyperparameter search while significantly reducing the required training steps. The approach pre-computes potential loop closure pairs offline and leverages them through an agent-guided curriculum, allowing the model to adapt efficiently to new scenarios. Experiments conducted on TartanAir for training and validated across multiple benchmarks including KITTI, EuRoC, ICL-NUIM and TUM RGB-D demonstrate that AutoLoop achieves comparable or superior performance while reducing training time by an order of magnitude compared to traditional approaches. AutoLoop provides a practical solution for rapid adaptation of visual SLAM systems, automating the weight tuning process that traditionally requires multiple manual iterations. Our results show that this automated curriculum strategy not only accelerates training but also maintains or improves the model's performance across diverse environmental conditions.

Figures

Figures reproduced from arXiv: 2501.09160 by the authors.

Figure 1
Figure 1. Loop Closure Detection Pipeline: The system processes TartanAir [PITH_FULL_IMAGE:figures/full_fig_p002_1.png] view at source ↗
Figure 3
Figure 3. Progression of the loop weight during DPVO fine-tuning using the [PITH_FULL_IMAGE:figures/full_fig_p004_3.png] view at source ↗
Figure 2
Figure 2. Pre-computed loop closure pairs distribution on TartanAir training [PITH_FULL_IMAGE:figures/full_fig_p004_2.png] view at source ↗

Discussion (0). Continue with ORCID to comment.

Reference graph

Works this paper leans on

34 extracted references · 32 canonical work pages

  1. [1]

    Orb-slam3: An accurate open- source library for visual, visual–inertial, and multimap slam

    Carlos Campos et al. “Orb-slam3: An accurate open- source library for visual, visual–inertial, and multimap slam”. In: IEEE Transactions on Robotics 37.6 (2021), pp. 1874–1890

    work page 2021

  2. [2]

    Vins-mono: A robust and versatile monocular visual-inertial state es- timator

    Tong Qin, Peiliang Li, and Shaojie Shen. “Vins-mono: A robust and versatile monocular visual-inertial state es- timator”. In: IEEE transactions on robotics 34.4 (2018), pp. 1004–1020

    work page 2018

  3. [3]

    Deep patch visual odometry

    Zachary Teed, Lahav Lipson, and Jia Deng. “Deep patch visual odometry”. In: vol. 36. 2024

    work page 2024

  4. [4]

    Deepv2d: Video to depth with differentiable structure from motion

    Zachary Teed and Jia Deng. “Deepv2d: Video to depth with differentiable structure from motion”. In: arXiv preprint arXiv:1812.04605 (2018)

    arXiv 2018

  5. [5]

    Deep patch visual slam

    Lahav Lipson, Zachary Teed, and Jia Deng. “Deep patch visual slam”. In: European Conference on Computer Vision. Springer. 2025, pp. 424–440

    work page 2025

  6. [6]

    Im- proved SLAM closed-loop detection algorithm based on DBoW2

    Qingsong Zhang, Guanghui Xu, and Na Li. “Im- proved SLAM closed-loop detection algorithm based on DBoW2”. In: Journal of Physics: Conference Series. V ol. 1345. 4. IOP Publishing. 2019, p. 042094

    work page 2019

  7. [7]

    VLAD-based loop closure detection for monocular SLAM

    Yao Huang, Fuchun Sun, and Yao Guo. “VLAD-based loop closure detection for monocular SLAM”. In: 2016 IEEE International Conference on Information and Au- tomation (ICIA). IEEE. 2016, pp. 511–516

    work page 2016

  8. [8]

    NetVLAD: CNN architecture for weakly supervised place recognition

    Relja Arandjelovic et al. “NetVLAD: CNN architecture for weakly supervised place recognition”. In: Proceed- ings of the IEEE conference on computer vision and pattern recognition. 2016, pp. 5297–5307

    work page 2016

Show all 34 references
  1. [9]

    Superglue: Learning feature matching with graph neural networks

    Paul-Edouard Sarlin et al. “Superglue: Learning feature matching with graph neural networks”. In: Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 2020, pp. 4938–4947

    2020

  2. [10]

    LoFTR: Detector-free local feature matching with transformers

    Jiaming Sun et al. “LoFTR: Detector-free local feature matching with transformers”. In: Proceedings of the IEEE/CVF conference on computer vision and pattern recognition. 2021, pp. 8922–8931

    2021

  3. [11]

    Curriculum learning

    Yoshua Bengio et al. “Curriculum learning”. In: Pro- ceedings of the 26th Annual International Conference on Machine Learning . ICML ’09. Montreal, Quebec, Canada: Association for Computing Machinery, 2009, pp. 41–48

    2009

  4. [12]

    Cur- riculum learning by transfer learning: Theory and ex- periments with deep networks

    Daphna Weinshall, Gad Cohen, and Dan Amir. “Cur- riculum learning by transfer learning: Theory and ex- periments with deep networks”. In: International con- ference on machine learning . PMLR. 2018, pp. 5238– 5246

    2018

  5. [13]

    gradSLAM: Au- tomagically differentiable SLAM

    Krishna Murthy Jatavallabhula et al. “gradSLAM: Au- tomagically differentiable SLAM”. In: arXiv preprint arXiv:1910.10672 (2019)

    2019 arXiv

  6. [14]

    Deepfactors: Real-time proba- bilistic dense monocular slam

    Jan Czarnowski et al. “Deepfactors: Real-time proba- bilistic dense monocular slam”. In: IEEE Robotics and Automation Letters 5.2 (2020), pp. 721–728

    2020

  7. [15]

    LoRa technology- an overview

    Shilpa Devalal and A Karthikeyan. “LoRa technology- an overview”. In: 2018 second international conference on electronics, communication and aerospace technol- ogy (ICECA). IEEE. 2018, pp. 284–290

    2018

  8. [16]

    Visual prompt tuning

    Menglin Jia et al. “Visual prompt tuning”. In: Euro- pean Conference on Computer Vision . Springer. 2022, pp. 709–727

    2022

  9. [17]

    Optimal Image-Aided Inertial Navigation

    Nilesh Sharma Gopaul. “Optimal Image-Aided Inertial Navigation”. In: (2018)

    2018

  10. [18]

    Deeplio: Deep lidar iner- tial sensor fusion for odometry estimation

    D Iwaszczuk, S Roth, et al. “Deeplio: Deep lidar iner- tial sensor fusion for odometry estimation”. In: ISPRS Annals of the Photogrammetry, Remote Sensing and Spatial Information Sciences 1 (2021), pp. 47–54

    2021

  11. [19]

    S-PTAM: Stereo parallel tracking and mapping

    Taihú Pire et al. “S-PTAM: Stereo parallel tracking and mapping”. In: Robotics and Autonomous Systems 93 (2017), pp. 27–42

    2017

  12. [20]

    maplab: An open framework for research in visual-inertial mapping and localization

    Thomas Schneider et al. “maplab: An open framework for research in visual-inertial mapping and localization”. In: IEEE Robotics and Automation Letters 3.3 (2018), pp. 1418–1425

    2018

  13. [21]

    Mono-hydra: Real-time 3D scene graph construc- tion from monocular camera input with IMU

    UVBL Udugama, George V osselman, and Francesco Nex. “Mono-hydra: Real-time 3D scene graph construc- tion from monocular camera input with IMU”. In: arXiv preprint arXiv:2308.05515 (2023)

    2023

  14. [22]

    Atloc: Attention guided camera localization

    Bing Wang et al. “Atloc: Attention guided camera localization”. In: Proceedings of the AAAI Conference on Artificial Intelligence. V ol. 34. 06. 2020, pp. 10393– 10401

    2020

  15. [23]

    Vision meets robotics: The kitti dataset

    Andreas Geiger et al. “Vision meets robotics: The kitti dataset”. In: The International Journal of Robotics Research 32.11 (2013), pp. 1231–1237

    2013

  16. [24]

    The EuRoC micro aerial vehicle datasets

    Michael Burri et al. “The EuRoC micro aerial vehicle datasets”. In: The International Journal of Robotics Research 35.10 (2016), pp. 1157–1163

    2016

  17. [25]

    A benchmark for RGB-D visual odometry, 3D reconstruction and SLAM

    Ankur Handa et al. “A benchmark for RGB-D visual odometry, 3D reconstruction and SLAM”. In: 2014 IEEE international conference on Robotics and automa- tion (ICRA). IEEE. 2014, pp. 1524–1531. 8

    2014

  18. [26]

    A benchmark for the evaluation of RGB-D SLAM systems

    Jürgen Sturm et al. “A benchmark for the evaluation of RGB-D SLAM systems”. In: 2012 IEEE/RSJ inter- national conference on intelligent robots and systems . IEEE. 2012, pp. 573–580

    2012

  19. [27]

    Robust Monocular Vi- sual Odometry using Curriculum Learning

    Assaf Lahiany and Oren Gal. “Robust Monocular Vi- sual Odometry using Curriculum Learning”. In: arXiv preprint arXiv:2411.13438 (2024)

    2024 arXiv

  20. [28]

    Droid-slam: Deep visual slam for monocular, stereo, and rgb-d cameras

    Zachary Teed and Jia Deng. “Droid-slam: Deep visual slam for monocular, stereo, and rgb-d cameras”. In: Advances in neural information processing systems 34 (2021), pp. 16558–16569

    2021

  21. [29]

    Deep Visual Odometry with Events and Frames

    Roberto Pellerito et al. “Deep Visual Odometry with Events and Frames”. In: Proceedings of the IEEE/RSJ International Conference on Intelligent Robots and Sys- tems (IROS. IEEE) . 2024

    2024

  22. [30]

    TartanAir: A dataset to push the limits of visual slam

    Wenshan Wang et al. “TartanAir: A dataset to push the limits of visual slam”. In: 2020 IEEE/RSJ International Conference on Intelligent Robots and Systems (IROS) . IEEE. 2020, pp. 4909–4916

    2020

  23. [31]

    Deep event visual odometry

    Simon Klenk et al. “Deep event visual odometry”. In: 2024 International Conference on 3D Vision (3DV) . IEEE. 2024, pp. 739–749

    2024

  24. [32]

    Tar- tanvo: A generalizable learning-based vo

    Wenshan Wang, Yaoyu Hu, and Sebastian Scherer. “Tar- tanvo: A generalizable learning-based vo”. In: Confer- ence on Robot Learning . PMLR. 2021, pp. 1761–1772

    2021

  25. [33]

    SVO: Fast semi-direct monocular visual odom- etry

    Christian Forster, Matia Pizzoli, and Davide Scara- muzza. “SVO: Fast semi-direct monocular visual odom- etry”. In: 2014 IEEE international conference on robotics and automation (ICRA) . IEEE. 2014, pp. 15– 22

    2014

  26. [34]

    Direct sparse odometry

    Jakob Engel, Vladlen Koltun, and Daniel Cremers. “Direct sparse odometry”. In: IEEE transactions on pattern analysis and machine intelligence 40.3 (2017), pp. 611–625

    2017

Pith tools

Reviewed August 10, 2026 · model on record in the stance chip above.