LiDAR odometry estimation is inevitable for autonomous systems such as mobile service robots and autonomous driving vehicles. A number of LiDAR odometry estimation and mapping algorithms have been proposed, and many autonomous systems are built based on these robust and accurate algorithms. However, these algorithms are often surprisingly complex and involve many hyperparameters. Their performance can be significantly affected by the choice of hyperparameters; therefore, the hyperparameters must be fine-tuned depending on the system and environment. Despite their significance, hyperparameters are manually tuned in most studies, which results in considerable human effort and suboptimal parameter sets. Although a few studies have proposed automatic parameter tuning methods for odometry estimation [Pomerleau_2011, Nobili_2017], they are all dedicated to specific algorithms, sensors, and task configurations [Pomerleau2015].
In our previous work, we proposed a general and automatic hyperparameter optimization approach for black-box odometry estimation methods [koide_icra2021]. This approach repeats the parameter-sampling-and-trial loop with efficient parameter space exploration based on sequential model-based optimization (SMBO). It uses only information on the input parameter set and output trajectory of the algorithm to be tuned (i.e., black-box modeling) and facilitates the improvement of the performance of any odometry estimation methods without detailed information on their inner working. Although this approach is effective in improving the performance of odometry estimation methods on certain metrics and datasets, we observed that it suffers considerably from overfitting to the training sequences. If the training set contains only easy sequences, the SMBO tends to choose a very aggressive parameter set that results in instability in other sequences. Conversely, if there is a difficult sequence in the training set, the optimized parameter set tends to be very conservative, resulting in deteriorated trajectory accuracy.
In this work, to deal with overfitting and achieve a balance between robustness and accuracy, we propose a data-driven approach for adaptively selecting the hyperparameters of black-box odometry estimation methods. The proposed framework automatically models the effects of the differences in hyperparameters on the behavior of the odometry estimation algorithm, and then selects the best parameter set for the current environment.
The proposed framework comprises offline parameter-error function modeling and online adaptive parameter selection. In the offline step, we run the odometry estimation algorithm with different parameter samples and environments and evaluate the trajectory estimation errors . Subsequently, we build a surrogate function that predicts the trajectory estimation error of the algorithm for a given parameter set and environment: . In the online step, we identify the parameter set that minimizes the predicted trajectory error for the current environment : .
We first demonstrate the role of the proposed framework in improving the accuracy of an odometry estimation algorithm across different environments through a simulation-based toy example. Further, an evaluation on the public dataset KITTI shows that the proposed framework can be used in real applications and improves the accuracy of odometry estimation algorithms with completely different architectures (Generalized ICP (GICP) odometry [Segal2009], LeGO-LOAM [Shan2018], and SuMa [Behley2018]).
Ii Related Work
SLAM and odometry estimation algorithms are inherently very complex and use many hyperparameters (e.g., point cloud resolution, feature matching threshold, and keyframe interval). It is known that, to achieve the best results, some popular SLAM frameworks such as Google Cartographer [Hess2016] need to fine-tune many hyperparameters that affect each other111https://google-cartographer-ros.readthedocs.io/en/latest/tuning.html. This tuning process requires a deep understanding of the inner working of the frameworks and considerable human effort of trial and error.
Despite the significance of hyperparameters, there are only a few studies on the automatic parameter tuning of SLAM-related algorithms. Nobili et al.
automatically optimized the outlier removal parameters of ICP algorithms for a humanoid robot based on a metric of the overlap between point cloud pairs[Nobili_2017]. Zheng used an exhaustive grid search to optimize the parameters of a visual SLAM algorithm (e.g., number of features, patch size, and edge threshold) [Zheng_2020]. Similarly, Permeleau et al. investigated the changes in the ICP registration accuracy depending on the parameter values using exhaustive parameter-by-parameter evaluation [Pomerleau_2011]. Although several techniques have been proposed for the fine-tuning of SLAM-related algorithms for specific use scenarios [Pomerleau2015], all the above works are dedicated to specific sensors, environments, and task configurations.
In the context of machine learning, hyperparameter tuning has been recognized as an important step in maximizing the performance of learning models[probst2019tunability]. When the number of parameters to be tuned is small, fine-tuning is often performed by exhaustive grid and random searches [random_search]. They are easy to implement and work well for classic models that use only a few parameters (e.g., RBF SVM parameter selection 
). However, the required number of evaluations with these methods rapidly increases as the number of parameters increases. Thus, they are not suitable for tuning computationally expensive models with many parameters (e.g., deep neural networks).
In recent years, the sequential model-based optimization (SMBO) approach has been used to efficiently optimize many parameters in computationally expensive models [NIPS2011_4443, Shahriari2016]
. This approach introduces a surrogate model that approximates the expensive model evaluation and samples the parameter set that maximizes an acquisition criterion (e.g., expected improvement) on the surrogate model. This facilitates the efficient exploration of the parameter space with fewer evaluations. Recent deep-learning-based methods, which require the optimization of many hyperparameters for an expensive training model, have benefited from SMBO-based automated hyperparameter tuning[Liang2018].
Although we can simply apply the SMBO approach to LiDAR odometry estimation such that the trajectory evaluation metric is minimized on training sequences[koide_icra2021], we observed that simple SMBO-based parameter optimization can considerably suffer from overfitting to the training sequences for two reasons. First, we typically have fewer training sequences in the odometry estimation problem compared to the usual machine learning problems. Second, the corruption of the trajectory estimation results in a catastrophic error in the trajectory evaluation metrics (e.g., absolute and relative trajectory errors [Zhang2018]), which causes the SMBO to choose a very conservative parameter set. It is difficult for most odometry estimation algorithms to deal with different environments using a single fixed parameter set; hence, we argue that an adaptive mechanism to select an appropriate parameter set depending on the environment is necessary to further improve the trajectory estimation accuracy across different environments.
Although there are a few works that adaptively optimize the hyperparameters of specific algorithms depending on the environment (e.g., adaptive octree-resolution selection for visual SLAM [Vespa2019]), to the best of our knowledge, no work has proposed a general and adaptive hyperparameter tuning framework without a limitation on the algorithms to be tuned.
Fig. 1 shows an overview of the proposed adaptive hyperparameter tuning framework for black-box odometry estimation algorithms. We first model a surrogate function offline that predicts the trajectory estimation error for a given parameter set and environment descriptor . To achieve this, we run the odometry estimation algorithm multiple times with different parameter samples and environments and evaluate the trajectory estimation errors . A k-nearest neighbor regressor-based surrogate function is then fitted to the evaluation results: . To efficiently explore the parameter space, we employ an SMBO-based parameter sampling technique. We then extract the environment descriptor for the input point cloud and identify the parameter set that minimizes the predicted error with the surrogate function: .
It should be noted that, while we assume uniform distributions for the parameters to be tuned for simplicity, the proposed framework can naturally be extended to accept other parameter distribution classes (e.g., discrete and categorical distributions).
Iii-a Offline Parameter-Error Function Modeling
For each training sequence , we run the odometry estimation algorithm multiple times with different parameter samples and obtain a set of estimated trajectories . The accuracy of each trajectory is evaluated using a metric , such as relative trajectory errors (RTEs) [Zhang2018]. We use the notation for brevity. To efficiently explore the parameter space, we employ the SMBO-based parameter sampling technique shown in Algorithm 1. The SMBO fits a surrogate model to the evaluation history and samples a parameter set that maximizes the acquisition criterion on the surrogate model. We use the expected improvement (EI) [Zhan2020] as the acquisition criterion, with the expectation that negatively exceeds a threshold :
The parameter set that maximizes EI can be determined by introducing two density functions and , which are respectively fitted to the evaluation history where and , and identifying the parameter set that maximizes .
is a threshold chosen such that the quantile. We refer the reader to [NIPS2011_4443] for a detailed derivation.
For parameter sampling, the SMBO is used to minimize the average translational RTEs. We set the number of SMBO iterations to 256, and thus obtain 256 parameter sets and corresponding trajectories for each training sequence. Fig. 2 shows example parameter values of LeGO-LOAM [Shan2018]
sampled with the SMBO. The blue line indicates the density of the sampled parameters given by the kernel density estimation. It can be observed that the SMBO efficiently explores the parameter space by taking more samples from the region where the error is expected to be small.
For each frame
, we calculate the RTEof the sub-trajectory starting from the frame with a parameter set . The parameter values are then concatenated with the environment descriptor of the starting frame
to compose a feature vector, which describes the combination of the environment and parameter values. We then model a surrogate function that predicts the estimation error for a given parameter set and environment by fitting a k-nearest neighbor regressor (k = 5) such that .
For simplicity, we use the descriptor of the first frame of a sub-trajectory to predict the trajectory estimation error. However, error prediction inherently requires information on all the frames in the time period of the sub-trajectory. Although this simplification can be justified by assuming that consecutive frames have similar environment structures in odometry estimation, extensions using a sequence of descriptors to capture drastic environmental changes and sensor motion can be considered in future work.
Iii-B Online Parameter Selection
For the online parameter selection, we first extract the environment descriptor for the input point cloud and find the parameter set that minimizes the predicted error with the surrogate function:
Because the surrogate function is a k-nearest neighbor regressor that is nonlinear and non-convex, its minimization is not trivial. Thus, we again use the SMBO parameter search to determine the best parameter set for the current environment. We perform parameter selection every second and update the parameter set.
Iii-C Environment Descriptor
As a descriptor to represent the environment structure, we use simple NDT (Normal Distributions Transform) voxel classification-based features[Magnusson2009]. Following [Magnusson2009]
, we calculate the normal distribution voxels for the input point cloud. Based on the eigenvalues of the covariance matrices (
), we classify the voxels into linear (), planar (), and spherical (other cases) distributions; is a constant in . Each distribution class has three subclasses based on the line tilt angle, plane tilt angle, and eigenvalue ratio (), and they are invariant to yaw rotation. We count the number of each subclass for several distance ranges and create a histogram (3.0 m 10 bins 9 sub-classes). We then apply PCA dimensionality reduction () to obtain the feature vector representing the environment structure.
It is worth mentioning that the proposed framework is agnostic to the environment descriptor, and other features (e.g., hand-crafted [Rusu2009] as well as learned features [Gojcic2019]) can be used with slight modifications.
Iv-a Simulation-based Toy Example
To demonstrate the process where the proposed framework adaptively selects parameters and improves the accuracy of the odometry estimation across different environments, we conducted experiments in a simulated environment, as shown in Fig. 3. The environment consists of a cave (A), open space (B), and outdoor street environments (C). They have very different environmental structures and thus require different parameter settings. We generate LiDAR point clouds at 10 Hz with the sensor configuration of Velodyne HDL32e.
We used a simple keyframe-based NDT scan matching odometry algorithm with only two parameters: NDT voxel resolution and keyframe update interval. This uses the NDT algorithm with the specified voxel resolution value, and updates the keyframe (registration target point cloud) every time the travelled distance from the last keyframe exceeds the keyframe interval threshold parameter. These parameters provide a trade-off between accuracy and stability (large voxel size: better convergence and lower accuracy, large keyframe interval: low drift and worse stability) and need to be tuned depending on the environment.
For offline parameter-error function modeling, we recorded four LiDAR data sequences and ground truth trajectories for each of the cave and outdoor environments. For each sequence, we sampled 256 parameter sets and calculated the translational RTEs of 25 m sub-trajectories to evaluate the estimated trajectories. For validation, we recorded a sequence across the cave, open space, and outdoor environments.
We ran the NDT scan matching odometry algorithm on the validation sequence with three parameter settings: 1) manually tuned baseline parameter set, 2) fixed parameter set tuned with SMBO for the training sequences, and 3) adaptively selected parameter sets. Fig. 4 shows a plot of the adaptively selected NDT resolution and keyframe interval parameters. It can be observed that small keyframe interval values were selected to prevent estimation corruption in the cave environment (A), whereas large interval values were selected after the sensor moved out from the cave to improve the accuracy (B)(C). It can also be observed that large NDT resolution values tend to be selected in (B) and (C) to better capture the structure of the open environments. It is worth emphasizing that the proposed framework automatically determines how the parameters should be tuned for different environments using the data-driven approach; consequently, it does not require detailed information on the inner working of the algorithm to be tuned.
|Tuned (Fixed)||0.759 (-0.008)|
|Tuned (Adaptive)||0.530 (-0.237)|
Values in parentheses are with respect to the baseline
Table I shows the averaged translational RTEs for the different parameter settings. Although the fixed tuned parameter set exhibited slightly better accuracy (0.759 %) compared to the manually tuned baseline (0.767 %), the improvement was small. This is because it needed to select a conservative parameter set for the cave environment, which did not result in accuracy improvement in the outdoor environment. In contrast, the adaptive parameter selection significantly improved the estimation accuracy (0.530 %). This is because it adaptively changed the parameter set from conservative to aggressive after leaving the cave environment.
This simple toy example illustrates the necessity of an adaptive parameter selection mechanism to enhance the trajectory estimation accuracy across different environments.
Iv-B Evaluation on KITTI
Next, we conducted an evaluation on a public LiDAR odometry dataset, KITTI, to demonstrate that the proposed approach improves the accuracy of several odometry estimation algorithms in practical situations. The dataset contained 11 sequences recorded using Velodyne HDL-64E at a rate of 10 Hz. We used sequences 00-05 for the parameter optimization, and sequences 06-10 for validation.
We evaluated three odometry estimation algorithms with different architectures: keyframe-based GICP odometry [Segal2009], LeGO-LOAM [Shan2018], and SuMa [Behley2018] 222The list of tuned parameters of each algorithm is available athttps://github.com/SMRT-AIST/automatic_tuning/blob/devel/adaptive_parameters.md. We added slight modifications to LeGO-LOAM and SuMa to dynamically update the hyper-parameters via ROS param mechanism. As the baseline, we manually tuned the parameter sets of the GICP odometry and LeGO-LOAM for sequence 00. For SuMa, we used the parameter set optimized for all the sequences in [Behley2018]. We compared the trajectory errors of these algorithms with 1) the manually tuned baseline parameter set, 2) a fixed parameter set optimized with SMBO for the entire training sequences, and 3) adaptively selected parameter sets (the parameter-error function is modeled on the training set offline, and the parameters are adaptively selected on each sequence online). For the parameter-error function modeling of the adaptive parameter selection, we used translational RTEs of 100 m sub-trajectories as the evaluation metric.
The offline parameter-error function modeling terminated in about six hours for each odometry estimation method. The online feature extraction and parameter optimization, which were executed every second, took 40 msec and 700 msec, respectively.
|Method||Training set||Test set|
|Fixed||1.21||2.45||1.66||1.08||0.99||0.61||1.34 (-0.12)||0.55||1.35||2.00||1.06||1.12||1.54 (+0.21)|
|Adaptive||1.21||2.16||1.48||0.97||0.78||0.64||1.26 (-0.20)||0.57||0.92||1.18||1.22||1.50||1.13 (-0.20)|
|Fixed||1.87||3.07||1.83||1.63||1.33||1.02||1.77 (-0.67)||1.09||1.02||1.76||1.29||1.83||1.56 (+0.04)|
|Adaptive||1.47||2.78||1.53||1.22||1.21||0.79||1.45 (-0.99)||0.90||1.02||1.58||1.28||1.73||1.43 (-0.09)|
|Fixed||0.84||5.59||1.27||1.14||0.56||0.87||1.35 (-0.17)||0.60||0.66||1.43||0.86||1.73||1.21 (-0.02)|
|Adaptive||0.90||5.69||1.24||1.19||0.58||1.00||1.39 (-0.13)||0.61||0.65||1.40||0.94||1.65||1.20 (-0.03)|
Values in parentheses are with respect to the baseline
Fig. 5 shows the parameters of the GICP odometry (maximum correspondence distance and keyframe interval) for each training sequence (sequence 00-05) sampled during the offline parameter-error function modeling. The color of the points indicates the translational RTE. It can be observed that different sequences require very different parameters. In particular, sequence 01, which is the most difficult sequence in KITTI owing to the feature-less environment structure, requires a very large maximum correspondence distance parameter to prevent estimation corruption. It can also be observed that the required keyframe interval is significantly changed for each sequence. This result clearly demonstrates the necessity of the adaptive parameter tuning mechanism. If a conservative parameter set is chosen for the difficult sequence (sequence 01), the estimation results of other sequences would deteriorate. Conversely, if a parameter set for another sequence (e.g., sequence 00) is chosen, the estimation would be corrupted on the difficult sequence. There is no parameter set that works well for all the sequences, and thus the parameter set must be adaptively selected depending on the environment.
Table II shows the translational RTEs averaged over 100 to 800 m trajectories for the odometry estimation algorithms with different parameter settings. We used the KITTI official evaluation code to calculate the RTEs.
Although the fixed parameter set optimized with SMBO improved the RTEs of the GICP odometry for the training sequences, the RTEs on the test set deteriorated compared to the baseline. This is because the fixed parameter selection strategy required to choose a conservative parameter set for the difficult sequences to improve the RTEs on the training set. The proposed approach significantly improved the RTEs on both the training and test sets by adaptively selecting the best parameter sets depending on the environment. Fig. 6 shows the adaptively selected keyframe interval values of the GICP odometry for sequence 08. Small interval values were selected on corners to prevent estimation corruption, whereas large values were selected on several long straight paths to reduce the odometry drift and achieve better accuracy.
The results of LeGO-LOAM exhibited a similar trend to that of the GICP odometry. Although the fixed parameter set significantly improved the translational RTEs on the training set, the RTEs on the test set deteriorated. The adaptive parameter selection successfully improved the RTEs for both the training and test sets.
Although both the fixed and adaptive parameter sets significantly improved the RTEs of SuMa on the training set, the improvement on the test set was very small. This may be because 1) the baseline parameter set was highly optimized for the entire dataset, and 2) the modified parameters affected the consistency of the surfel map of SuMa, resulting in better accuracy in some test sequences (sequences 06, 07, 09, and 10) but worse accuracy in a long sequence (sequence 08). These results indicate the shortcomings of the current form of the proposed framework; it uses a simple environment descriptor and regression model that may not capture the fine behavior of the odometry estimation algorithm. We infer that this can be further improved by considering as input environment descriptor sequences to better represent the changing environmental structures and introducing a small amount of prior information on the relationship between the parameters and odometry estimation algorithm behavior.
This study proposed an automatic and adaptive hyperparameter tuning framework for black-box LiDAR odometry estimation algorithms. The proposed method first runs the odometry estimation algorithm to be tuned with different parameters and environments offline, and creates a surrogate function to predict the estimation error for novel parameters and environments. For online parameter selection, it chooses the parameter set that is expected to yield better accuracy in the given environment with the surrogate function. We employed an SMBO technique for efficient offline parameter space exploration and online surrogate function minimization. The evaluation results showed that the proposed approach improves the accuracy of the odometry estimation algorithms without detailed information on their inner working.
While it has been shown that the proposed framework enables to adaptively optimize hyper-parameters across different environments, it is still challenging to select good parameters in novel environments. We plan to further evaluate and enhance the generality of the adaptively tuning framework with, e.g., data augmentation and regularization techniques.
This work was supported in part by a project commissioned by the New Energy and Industrial Technology Development Organization (NEDO).