How air-ufg/delora works
Main Components
• Data Ingestion & Preprocessing:
– Directories: src/data, src/preprocessing, and datasets
– Role: This component is responsible for reading in LiDAR scan data from various sources (e.g., KITTI dataset and rosbag files) and preprocessing them (e.g., normal computation, kd-tree generation). The configuration files in the config/ folder (e.g., config_datasets.yaml) inform settings such as sensor specifications.
• Model & Loss Computation:
– Directories: src/models and src/losses
– Role: The core neural network (including the modified ResNet, model parts, etc.) is defined here along with the loss functions (e.g., ICP losses) for self-supervised training.
• Deployment & Training/Testing Management:
– Directories: src/deploy (with deployer.py, trainer.py, tester.py) and the various executable scripts in the bin/ and scripts/ folders
– Role: This module manages training, testing, and deployment routines. It integrates parameter configurations (from config/hyperparameters.yaml and deployment_options.yaml), manages experiment logging with MLFlow, and handles checkpoint usage.
• ROS Integration & Utilities:
– Directories: src/ros_utils
– Role: This part of the system is specific to robotic applications. The ROS nodes handle the conversion of data (e.g., converting scans to rosbag messages, publishing odometry as nav_msgs/Odometry) and integrate the pretrained models into live ROS pipelines.
• Utility & Helper Functions:
– Directories: src/utility
– Role: Implements general-purpose functions (e.g., geometry, linear algebra, plotting) that support other modules.
• Environment & Dependencies:
– Files/directories: conda/, pip/, Dockerfile under docker/
– Role: These files define the runtime, dependencies (PyTorch, CUDA, ROS), and containerization setup which are crucial for the reproducibility and deployment of the project in various environments.
• The Training/Testing module (src/deploy) interfaces with both the model and the loss module.
• An independent branch where the ROS Integration module (src/ros_utils) uses a pretrained model for inference and publishes results through ROS topics.
Architectural Patterns and Design Principles
– Separation of Concerns: Each directory encapsulates a specific responsibility (data, model, deployment, ROS, utilities).
– Modularity: The design is modular; for example, the preprocessing and ROS utilities can be modified or extended without impacting core model training.
– Config-driven Behavior: Multiple configuration files allow customization of datasets, hyperparameters, and deployment options.
– Environment Management: Use of Conda (and optionally Docker) ensures consistency in dependencies for both training and inference.
Relevant Technologies, Frameworks, and Libraries
– PyTorch: Provided in the conda environment and used for the model.
– ROS/ROS Noetic: Specifically in src/ros_utils for integrating with robotic systems.
– MLFlow: For experiment and parameter logging.
– CUDA/cuDNN: For GPU acceleration (handled through the conda environment).
– Docker: For containerized deployment (see docker/Dockerfile).
Summarizing the Process
– Start by listing front-line external inputs (raw LiDAR data, ground truth poses) from the datasets.
– Map their journey through preprocessing (normal computation, kd-tree generation).
– Show the flow into the core deep learning model that predicts odometry, with loss functions guiding training.
– Illustrate how the system supports iterative training with checkpoints and logging, and how it eventually deploys via a ROS node for real-time inference.
– Also indicate that support scripts (for training continuation, model conversion, and time benchmarking) offer additional capabilities that might be drawn as auxiliary components linked to the main flow.