DevGRU is a deep learning-based navigation framework designed for long-horizon navigation without requiring global localization or a dense obstacle map.
This package contains the implementation of our RA-L paper: DevGRU: Depth-Guided Visual Navigation Using a Collision-Aware Recurrent Model. Please refer to the paper for details regarding the technical aspects of this package.
Given a pre-built topological map, the robot sequentially visits intermediate sub-goals to reach the final destination. DevGRU leverages both depth observations and point-goal information for navigation.
Pretrained weights and dataset are available at: Pretrained Weights and Dataset.
DevGRU is designed to operate within a ROS-based Conda Env:
- Ubuntu 20.04
- ROS Noetic
- Conda
To run DevGRU, two main components must be installed:
- DevGRU (this repository): training and deployment framework
- NavDataCollector: dataset collection and deployment support
This repository provides code for training and deploying DevGRU for topological navigation using depth and sub-goal information.
./train/: training code for DevGRU models./train/devgru_train/models/: model definitions for the Action Predictor (AP), Collision Predictor (CP), and related baselines./deployment/src/: deployment scripts for running DevGRU on a robot platform in real-world environments
This package is used for dataset collection and real-world deployment. Install it using the following commands:
cd ~/catkin_ws/src
git clone https://github.com/han-kyung-min/navdata_collector.git
cd ~/catkin_ws
catkin_make installMake sure to install ROS-noetic and Conda prior to the following procedures.
- Clone DevGRU project
git clone https://github.com/han-kyung-min/devgru
cd devgru
git checkout master
- Set up the conda environment:
conda env create -f train/train_environment.yml
To activate env
conda activate devgru_train
- Install Conda for managing environments. We recommend you Miniconda
Make conda env with environment.yml
conda env create -f deployment/deployment_environment.yml
To activate env
conda activate devgru_deployment
Make sure to install the DevGRU project before proceeding with the steps below.
Open the devgru.yaml file located at: /devgru/config/
Modify the configuration to correctly set the dataset paths in the following section:
devgru['data_split']['former']
Ensure that the following fields are properly specified:
i.
data_folder
ii.train
iii.test
Run the following commands to split the real-world dataset collected from the FORMER robot.
cd $PROJECT_DIR/train
conda activate devgru_train
python split_data.py
Here, $PROJECT_DIR refers to the root directory of the DevGRU project (e.g., /home/$USER/python_ws/viznav/devgru).
Open the devgru.yaml file located at: $PROJECT_DIR/config/
Modify the configuration to correctly set the dataset paths in the following section: devgru['datasets']['former']
Ensure that the following fields are properly specified:
i.
data_folder
ii.train
iii.test
Run the following commands to start training:
cd $PROJECT_DIR/train
conda activate devgru_train
python train_action_predictor.py
Open the devgru.yaml file located at: $PROJECT_DIR/config/
Modify the configuration to correctly set the dataset paths in the following section:
devgru['datasets']['former']
Ensure that the following fields are properly specified:
i.
data_folder
ii.train
iii.test
Run the following commands to start training:
cd $PROJECT_DIR/train
conda activate devgru_train
python train_collision_predictor.py
The trained models and their logs are saved under $PROJECT_DIR/train/logs using the time and date as the ID of the training session.
Make sure that both the DevGRU project and NavDataCollector are installed before proceeding with the steps below.
Although users can train models by following the training step
we also provide pre-trained models available at THIS LINK
The trained models should be copied to $PROJECT_DIR/deployment/model_weights
Move the robot to the starting position and reset the odometry.
For Former robot users, run in the robot's terminal:
sudo service former stop sudo service former startAlternatively, rebooting the robot will also reset the odometry.
Next, modifiy the navdata_collector.yaml located under ~/catkin_ws/src/navdata_collector/params/ to specify the path for saving bag files.
In particular, update the following field: navdata_collector['navdata_collector']['bagfile_root_path'] to your desired directory for storing bag files.
Then, Follow the proceedure below:
(i) Run the recording script
cd $PROJECT_DIR/deployment/src
./record_topomap_bag.sh
(ii) Press 'y' and hit 'Enter' to start recording a bagfile.
(iii) Move the robot to explore the environment and record the topological map data.
(iv) Once the robot reaches the desired destination, press 'q' and hit 'Enter' to stop recording.
This command launches run_manual_data_collection.py installed under ~/catkin_ws/install/lib.
The process records a ROS bag file containing relevant messages and also saves SLAM map files (e.g., pose graph and associated data) upon completion.
Similar to the previous step, modify navdata_collector.yaml to set the correct paths for extracting bag file data.
Specifically, update the following fields:
navdata_collector['navdata_extractor']['inpath']
navdata_collector['navdata_extractor']['outpath']
$INPATH: Directory generated from the previous data collection step (typically named in the formatYYYY-MM-DD-HH-MM).
This directory usually contains subfolders such asbag_YYYY-MM-DD-HH-MM-SS.$OUTPATH: Directory where the extracted data will be saved.
This must be a different directory from$INPATH.
After configuring the paths, execute the following command to generate the topological map from the recorded bagfile:
source set_ros_local.sh
cd ~/catkin_ws/src/navdata_collector/run_script/data_extractor
./generate_topomap_from_bag.sh
set_ros_local.sh sets ROS_MASTER_URI to 127.0.0.1, disconnecting the session from the robot’s ROS master.
The following procedure extracts and synchronizes the metadata from the bag files recorded in the previous step.
The extracted data is then copied to $TOPOMAP_DIR, where slam_poses.txt and the final topological map are generated.
After completing Steps 1 and 2, you are ready to start autonomous navigation.
Open the set_ros_former.sh script located in ~/catkin_ws/src/navdata_collector/run_script/data_extractor and modify the IP addresses as needed.
Then, do the following procedure:
(a) Place the robot at the starting position of the topological map,
(b) Ensure that the robot’s odometry is initialized
(c) Execute the navigation process using the following commands:
cd ~/catkin_ws/src/navdata_collector/run_script/data_extractor source set_ros_former.sh cd $PROJECT_DIR/deployment/src python run_navigate_viz.py
set_ros_former.shsetsROS_MASTER_URIandROS_HOSTNAMEaccording to the values specified in the file, allowing the PC to connect to the robot. The following procedure extracts and synchronizes the metadata from the bag files recorded in the previous step.
The extracted data is then copied to$TOPOMAP_DIR, whereslam_poses.txtand the final topological map are generated. configures ROS_MASTER_URI and ROS_HOSTNAME.
The remaining commands execute the navigation procedure.
If you want to record navigation logs with SLAM (not required for navigation, but useful for quantitative analysis),
use the following command instead ofrun_navigate_viz.py.cd $PROJECT_DIR/deployment/src ./run_navigate_viz_stack.py
This codebase builds upon the implementation of ViNT (Vision-based Navigation Transformer).
We thank the authors for making their code publicly available.
Parts of the data processing pipeline and source code are adapted from the ViNT project, with modifications to support the DevGRU framework.
If you find DevGRU useful in your research, please cite our paper:
@article{HanKim26,
author = {Kyung Min Han and Eunsom Kim and Young J. Kim},
title = {DevGRU: Depth-guided Visual Navigation using a Collision-aware Recurrent Model},
journal = {IEEE Robotics and Automation Letters (RA-L)},
year = {2026}
doi={10.1109/LRA.2026.3730213}
}