Self-Supervised Learning of End-to-End 3D LiDAR Odometry for Urban Scene Modeling

Abstract

Accurate and robust spatial perception is fundamental for dynamic 3D city modeling and urban environmental sensing. High-resolution remote sensing data, particularly LiDAR point clouds, are pivotal for these tasks due to their lighting invariance and precise geometric information. However, processing and aligning sequential LiDAR point clouds in complex urban environments presents significant challenges: traditional point-based or feature-matching methods are often sensitive to urban dynamics (e.g., moving vehicles and pedestrians) and struggle to establish reliable correspondences. While deep learning offers solutions, current approaches for point cloud alignment exhibit key limitations: self-supervised losses often neglect inherent alignment uncertainties, and supervised methods require costly pixel-level correspondence annotations. To address these challenges, we propose UnMinkLO-Net, an end-to-end self-supervised LiDAR odometry framework. Our method is as follows: (1) we efficiently encode 3D point cloud structures using voxel-based sparse convolution, and (2) we model inherent alignment uncertainty via covariance matrices, enabling novel self-supervised loss based on uncertainty modeling. Extensive evaluations on the KITTI urban dataset demonstrate UnMinkLO-Net’s effectiveness in achieving highly accurate point cloud registration. Our self-supervised approach, eliminating the need for manual annotations, provides a powerful foundation for processing and analyzing LiDAR data within multi-sensor urban sensing frameworks.

1. Introduction

Accurate and robust 3D point cloud alignment is fundamental to LiDAR-based urban scene modeling, enabling high-precision reconstructions essential for digital twins, infrastructure monitoring, and urban dynamics analysis. While large-scale modeling typically achieves centimeter-level accuracy in open environments using GNSS-RTK positioning, this approach suffers significant degradation in complex urban settings. Tall urban canyons, densely wooded areas, and obstructed spaces induce non-line-of-sight (NLOS) and multipath effects that substantially increase positioning errors [1]. Although mitigation techniques exist [2,3,4,5,6,7], they often fail to meet high-precision modeling requirements. Consequently, LiDAR sensor data have emerged as the primary solution for precise point cloud alignment when external positioning is unreliable.

LiDAR technology has become the cornerstone sensor for urban 3D modeling due to its lighting invariance, long-range capability, and measurement accuracy. Modern mobile mapping platforms deploy multi-line LiDAR sensors that capture detailed spatial representations through direct time-of-flight measurement. Unlike passive cameras, these active sensors maintain operational stability under challenging illumination and weather conditions. This robustness has established point cloud registration algorithms as essential techniques for continuous reconstruction in complex environments like urban canyons and vegetated areas [8,9].

Traditional reconstruction methods employ either direct point registration or geometric feature matching. While effective in static scenes, they exhibit critical limitations in urban environments: sensitivity to dynamic objects (e.g., vehicles and pedestrians) causing alignment errors, performance degradation from point cloud sparsity and measurement noise, and a requirement for manual parameter tuning across diverse urban contexts.

Deep learning approaches have demonstrated potential in addressing these challenges through end-to-end feature extraction [10,11,12,13,14,15,16,17,18,19,20]. However, prevailing methodologies exhibit fundamental limitations.

Projection-based methods [10,11,14] process range images derived from cylindrical or spherical projections using 2D convolutional neural networks (CNNs). This representation inherently discards the essential three-dimensional structural relationships.

Self-supervised approaches [12,13] mitigate dependency on labeled data by utilizing pose-predicted point cloud alignment as supervisory signals. Nevertheless, these methods manifest critical deficiencies: (1) dependence on 2D CNN architectures (e.g., DeepLO [12] and DeLORA [13]) that fail to capture complete 3D geometric information; (2) optimization objectives based exclusively on geometric consistency metrics (e.g., Chamfer distance and photometric error), while neglecting the detrimental effects of point cloud sparsity and sensor noise on alignment precision.

Beyond methodological limitations, learning-based LiDAR odometry must contend with four fundamental challenges: (1) data characteristics, including unordered, sparse point distributions with measurement uncertainties; (2) environmental complexity from reflective surfaces and complex structures generating outliers; (3) scene dynamics where moving objects introduce occlusion noise; (4) platform motion characteristics like vibration that degrade data quality.

To overcome these limitations, we propose UnMinkLO-Net, a self-supervised LiDAR odometry framework featuring 3D sparse convolution to preserve geometric structure (replacing cylindrical projection) and a novel uncertainty-aware loss modeling alignment errors through covariance estimation. Our end-to-end approach estimates 6-DoF poses without ground-truth supervision. Innovations of this work include the following:

• We propose an end-to-end LiDAR odometry network, UnMinkLO-Net, which uses 3D sparse convolution to preserve the 3D geometric structure and employs a covariance matrix to model alignment uncertainty between point clouds.
• We design a self-supervised loss function based on uncertainty modeling, enabling training without pose ground truth, making it suitable for scenarios where pose labels are hard to obtain.
• Experiments on the KITTI dataset show that UnMinkLO-Net can effectively estimate pose transformations between consecutive LiDAR frames and outperforms existing self-supervised 2D-convolution-based methods in accuracy.

2. Related Works

2.1. LiDAR Odometry Based on Point Cloud Registration

Point-based LiDAR odometry methods estimate ego-motion by iteratively optimizing the correspondence between pairs of sequential LiDAR point clouds to obtain the optimal pose transformation. Among these, the iterative closest point (ICP) algorithm [21] is the most widely recognized. ICP is a modular framework that aligns two point clouds by establishing point correspondences through a nearest neighbor search (NNS). However, one of the major limitations of ICP is its high computational cost when processing dense point clouds due to the complexity of nearest neighbor search. Additionally, the non-convex nature of the optimization makes the algorithm highly sensitive to the accuracy of the initial transformation. Moreover, outliers caused by dynamic objects can introduce further non-convexity into the optimization process.

To enhance the performance of ICP in terms of both efficiency and accuracy, various improved variants have been proposed, such as normal-ICP [22] and generalized ICP (G-ICP) [23,24,25]. Among these, G-ICP is particularly favored for its high accuracy. It formulates the registration problem as the optimization of a distribution-to-distribution cost function, considering the local geometry of point distributions rather than relying solely on point locations. This modeling makes G-ICP more robust to poor initializations. Nevertheless, like traditional ICP, G-ICP still depends on computationally expensive nearest neighbor searches, which significantly impact its runtime performance [22].

Beyond ICP and its derivatives, other point-based registration approaches exist. For instance, the normal distribution transform (NDT) [26] estimates transformations by leveraging voxel-level associations instead of traditional point-wise nearest neighbor matching, leading to improved efficiency. Specifically, NDT divides the input point cloud into multiple voxels and models each voxel using a Gaussian distribution. A second point cloud is then matched against this voxelized representation by optimizing a suitable cost function. While NDT offers faster computation compared to ICP, its accuracy is highly sensitive to the voxel resolution, which must be carefully tuned based on the sensor and environment. Furthermore, NDT requires a relatively accurate initial pose for successful convergence.

Recent years have seen significant advances in sensor fusion frameworks. FAST-LIO [27] and its successors (e.g., FAST-LIO2 [28]) demonstrate exceptional real-time performance through tightly coupled IMU-LiDAR fusion using iterated Kalman filtering on manifolds (IKFoM). These methods achieve remarkable efficiency on resource-constrained platforms but fundamentally address a different problem domain (multi-sensor state estimation) than our focus on pure LiDAR odometry.

A notable feature-based LiDAR odometry approach is LOAM [29,30], which was designed to reduce the computational load associated with ICP. LOAM extracts edge and planar features based on local smoothness in the point cloud. Unlike general feature descriptors such as FPFH [31,32,33,34] or SHOT [35,36], which extract multiple types of local descriptors, LOAM focuses only on two types of features, combining the strengths of both point-based and feature-based methods. On the one hand, it avoids using the full raw point cloud, enabling efficient registration. On the other hand, it aligns extracted features with a dense edge/plane map, performing scan-to-map rather than scan-to-scan matching. The use of Euclidean distance for feature matching helps reduce false correspondences and improves robustness. LOAM has demonstrated outstanding performance across various autonomous driving datasets. However, its accuracy is not always guaranteed across diverse scenarios. LeGO-LOAM, an extension of LOAM, refines the matching and optimization steps by using ground points to optimize the vertical component of the pose, thereby reducing vertical drift [37]. For real-time applications, both LOAM and LeGO-LOAM divide the odometry process into high-frequency scan-to-scan tracking and low-frequency scan-to-map updates. Nonetheless, LOAM’s reliance on simple edge and planar feature extraction may lead to performance degradation in scenes with complex geometric structures. Additionally, dynamic objects in the environment may disrupt feature associations, potentially resulting in inaccurate pose estimates.

2.2. LiDAR Odometry Based on Deep Learning

End-to-end LiDAR odometry aims to estimate ego-motion by leveraging deep neural networks to learn a direct mapping from raw point cloud data to relative pose transformations. Due to the unordered and irregular structure of point clouds, traditional convolutional neural networks (CNNs) are not directly applicable. To address this challenge, several methods [10,11,12,13] project 3D point clouds onto 2D representations to enable the use of conventional CNNs. For instance, Velas et al. [11] employed cylindrical projection to convert 3D LiDAR scans into three-channel 2D matrices, which are then processed by CNNs to estimate the pose of sequential scans. However, this approach formulates the odometry problem as a classification task rather than a regression problem and only estimates translational motion, failing to capture the full six degrees of freedom (6-DoF) motion accurately.

LO-Net [10] proposed a novel deep learning architecture for LiDAR-based ego-motion estimation. It extracts motion-relevant features from pairs of consecutive scans, predicts uncertainty masks to identify valid static regions, and enforces spatiotemporal geometric consistency using normal vector-based alignment. LO-Net was the first deep-learning-based LiDAR odometry framework to achieve accuracy comparable to traditional geometric methods.

Although projecting 3D data into 2D helps address point cloud disorder, it inevitably distorts the original 3D geometric structure. Performing convolutions on the resulting 2D images often leads to incorrect data associations, as convolutional kernels may blend foreground and background points, undermining the extraction of meaningful depth features. To overcome these limitations, more recent end-to-end odometry frameworks have adopted point cloud-specific feature extractors that operate directly on 3D data. Inspired by scene flow estimation, Wang et al. introduced PWCLO-Net [15], an end-to-end odometry network based on PointNet++ [38]. PWCLO-Net utilizes a coarse-to-fine hierarchical embedding strategy to progressively refine pose estimates. It builds an attention-based cost volume to associate two point clouds and extract embedded motion patterns. Moreover, a learnable embedding mask is introduced to weight local motion patterns of individual points, thereby improving global pose regression and filtering outliers.

Most existing approaches, including recent supervised methods like DSLO [19] and TransLO [16], achieve high accuracy but require ground-truth trajectories as supervision during training. These are typically acquired using high-precision inertial navigation systems that are not viable in occluded or indoor environments, limiting their applicability. In contrast, our work focuses on label-free self-supervision. To address this limitation, DeepLO [12] introduced a self-supervised loss function based on the iterative closest point (ICP) algorithm [21], enabling network training without access to ground-truth trajectories. DeepLO enforces geometric consistency between adjacent scans by aligning them using predicted poses and minimizing the residual differences between aligned point clouds. It encodes projected point clouds using a feature extractor and employs VertexNet to estimate per-point uncertainty, while PoseNet regresses the relative transformation. The self-supervised loss is computed using vertex maps and estimated normal vectors, with uncertainty-based weighting to mitigate the influence of dynamic objects.

DeLORA [13] further advances this line of work by proposing a lightweight and general self-supervised end-to-end LiDAR odometry framework. While it retains the geometric consistency-based loss from DeepLO, it omits the confidence estimation module to improve runtime efficiency. Additionally, DeLORA moves normal vector estimation to the preprocessing stage, allowing reuse across multiple training iterations and significantly reducing training time.

In summary, existing self-supervised end-to-end LiDAR odometry approaches face two major limitations: most methods, such as DeepLO and DeLORA [12,13], rely on 2D projections for convolution, which inevitably compromise the 3D topological structure of the original point cloud. Current self-supervised loss functions are primarily based on geometric consistency between adjacent frames [12,13]. However, due to the sparse nature and measurement noise of LiDAR data, even ground-truth-aligned scans cannot guarantee perfect geometric consistency. These loss functions do not explicitly model the inherent alignment errors between point clouds. To further enhance the accuracy and generalizability of end-to-end LiDAR odometry, it is imperative to develop improved self-supervised loss functions that explicitly model the intrinsic misalignment between adjacent scans.

3. Method

3.1. Problem Description

There are two point clouds captured by the LiDAR sensor at time steps k and $k-1$, denoted as ${\mathcal{S}}_k\in {\mathbb{R}}^{n_k\times 4}$ and ${\mathcal{S}}_{k-1}\in {\mathbb{R}}^{n_{k-1}\times 4}$, where $n_k$ and $n_{k-1}$ represent the number of points collected at each respective time. Each point $s_i\in \mathcal{S}$ is a four-dimensional vector $[x_i,y_i,z_i,I_i]$, where $p_i=\{x_i,y_i,z_i\}$ denotes the 3D coordinates of the point $s_i$, and $I_i$ is its intensity value. The objective of LiDAR odometry is to estimate the relative pose transformation at time t, denoted as $T_{k-1,k}=\{q_{k-1,k}\in {\mathbb{R}}^4,t_{k-1,k}\in {\mathbb{R}}^3\}$, which represents the transformation from the source point cloud ${\mathcal{S}}_k$ to the target point cloud ${\mathcal{S}}_{k-1}$. Here, $t_{k-1,k}$ is the translational component and $q_{k-1,k}$ is the rotational component of the pose transformation. Due to the influence of platform motion, LiDAR measurement noise, and dynamic objects in the environment, the relationship between the relative pose transformation $T_{k-1,k}$ and the point clouds ${\mathcal{S}}_{k-1},{\mathcal{S}}_k$ can be modeled by the following conditional probability density function:

$$p\left(T_{k-1,k}\right|{\mathcal{S}}_{k-1},{\mathcal{S}}_k).$$

(1)

Assuming there exists unique and deterministic mapping from a pair of point clouds to the corresponding relative pose transformation, ${\mathcal{S}}_{k-1},{\mathcal{S}}_k\mapsto T_{k-1,k}$. This chapter models such mapping using a neural network. The network approximates this deterministic function as follows: ${\widehat{T}}_{k-1,k}(\theta ,{\mathcal{S}}_{k-1},{\mathcal{S}}_k)$, where $\theta \in {\mathbb{R}}^P$ represents the learnable parameters of the network, and P denotes the total number of parameters. During training, the network is optimized by minimizing a loss function $\mathcal{L}$, which guides the learning process. The optimization objective can be formulated as follows:

$${\theta }^{*}=\arg \underset{\theta }{\min }\mathcal{L}\left({\widehat{T}}_{k-1,k}(\theta ,{\mathcal{S}}_{k-1},{\mathcal{S}}_k)\right).$$

(2)

3.2. Algorithm Description

This chapter presents UnMinkLO-Net, a self-supervised end-to-end LiDAR odometry framework. The overall architecture and workflow of UnMinkLO-Net are illustrated in Figure 1. A pair of consecutive point clouds is first passed through a Siamese network-based feature extraction module to obtain high-dimensional point-wise features. These features are then fed into a BEV (bird’s-eye view) projection-based feature fusion module, which fuses the spatial and semantic information of both frames. The fused features are subsequently processed by a relative pose regression module, which estimates the relative transformation between the two frames. The output of the regression module is the predicted relative pose transformation: ${\widehat{T}}_{k-1,k}=\{{\widehat{q}}_{k-1,k}\in {\mathbb{R}}^4,{\widehat{t}}_{k-1,k}\in {\mathbb{R}}^3\}$, where $\widehat{t}$ denotes the translational component represented as a 3D vector, and $\widehat{q}$ is the rotational component represented as a quaternion. The red dashed arrows in Figure 1 represent the gradient flow during training, which passes through the proposed self-supervised loss function based on point cloud uncertainty modeling.

3.2.1. Point Cloud Feature Extraction

Existing LiDAR odometry methods based on cylindrical projection and 2D convolution often distort the inherent 3D topological relationships between points when projecting them onto a 2D plane, hindering the network’s ability to effectively learn 3D structural information. To overcome this limitation, we adopt 3D convolutional networks that can directly extract meaningful features from point clouds in 3D space. To fully leverage the sparsity and non-uniform distribution of LiDAR sensor data, we represent 3D point clouds using sparse tensors. Additionally, to ensure efficient feature extraction, we design a point cloud feature extraction module based on the MinkowskiEngine [39] sparse convolutional network. This module comprises two main components: point cloud voxelization and feature extraction.

(1)

Point Cloud Voxelization

Let the 3D space E have dimensions $(D,W,H)$ along the x-, y-, and z-axes, respectively. We divide this space into a regular grid, where each grid cell $e_i$ is referred to as a voxel. All voxels have identical sizes, with dimensions $(v_x,v_y,v_z)$ in length, width, and height, respectively. After voxelization, the resulting grid has dimensions $(D/v_x,W/v_y,H/v_z)$. Each point $s_i$ in the input point cloud $\mathcal{S}$ is then assigned to the voxel $e_i$ that contains it. Due to the inherent sparsity of LiDAR point clouds, many voxels may contain no points, while others may contain only a few. For example, when the voxel size is set to $(10\mathrm{cm},10\mathrm{cm},20\mathrm{cm})$, some voxels may contain as few as 2 to 3 points. The voxelization process produces a structured grid in which each voxel $e_i$ has a coordinate index $(e_i^x,e_i^y,e_i^z)$. If a voxel contains no points, it is marked as empty. If a voxel contains multiple points, we compute the arithmetic mean ${\overline{s}}_i$ of all the points within the voxel to represent it, thereby improving computational efficiency. This process is illustrated in Figure 2. As a result, each voxel contains one representative point at most, yielding a downsampled point cloud denoted as ${\mathcal{S}}^{ds}$.

(2)

Feature Extraction

The feature extraction module is implemented as a weight-sharing Siamese network, where each of the two branches independently extracts features from a pair of adjacent point cloud frames. As illustrated in Figure 3, the downsampled point cloud ${\mathcal{S}}^{ds}$ is first converted into a sparse tensor representation $\mathcal{V}$. Specifically, the voxel coordinates $e_i$ of non-empty cells and the corresponding representative point ${\overline{s}}_i$ within each voxel are extracted, where $e_i$ denotes the voxel index and ${\overline{s}}_i$ serves as the voxel feature. This results in a sparse tensor representation of the form $\mathcal{V}=\{\mathrm{coords}\in {\mathbb{Z}}^{n_v\times 3},\mathrm{feat}\in {\mathbb{R}}^{n_v\times 4}\}$. A stacked sparse convolutional network is then employed to extract high-dimensional features from the sparse point cloud data. Sparse convolutions effectively capture local 3D geometric features while ignoring empty voxels, thereby improving computational efficiency. Furthermore, during the downsampling process, sparse convolutions preserve the underlying geometric structures and spatial topology, enabling multi-scale feature extraction. As a result, the network outputs the extracted features $V_k$ and $V_{k-1}$ corresponding to the source point cloud ${\mathcal{S}}_k$ and the target point cloud ${\mathcal{S}}_{k-1}$, respectively.

3.2.2. Point Cloud Feature Fusion

After extracting the features of the source and target point clouds, denoted as $V_k$ and $V_{k-1}$, respectively, we introduce a feature fusion module to facilitate the subsequent prediction of the relative transformation ${\widehat{T}}_{k-1,k}$ between adjacent frames by the pose regression network. As visualized in Figure 4, this module operates as follows: to reduce memory consumption and improve computational efficiency, the sparse voxel features $V_k$ and $V_{k-1}$ are first converted into dense voxel grids, resulting in 3D feature volumes $G_k$ and $G_{k-1}$. Following the approach in [40], these 3D grids are then projected into 2D feature maps ${\mathcal{M}}_k$ and ${\mathcal{M}}_{k-1}$ using a bird’s-eye view (BEV) projection.

Notably, this hybrid approach balances efficiency and 3D structure preservation, leveraging BEV’s strengths for feature fusion only after robust volumetric encoding, aligning with principles in VoxelNet [40] and PointPillars [41].

Finally, the projected feature maps ${\mathcal{M}}_k$ and ${\mathcal{M}}_{k-1}$ are concatenated along the channel dimension to form the fused feature map ${\mathcal{M}}_{k-1,k}$. This fused representation is a 3D tensor comprising feature channels, width, and length. Here, the spatial dimensions (width and length) correspond to the BEV-projected plane, while the channel dimension encodes both ground-level and vertical features. The first half of the channels corresponds to the source point cloud ${\mathcal{S}}_k$, and the second half to the target point cloud ${\mathcal{S}}_{k-1}$.

3.2.3. Relative Pose Regression

In this work, we aim to regress the relative pose transformation from the source point cloud ${\mathcal{S}}_k$ to the target point cloud ${\mathcal{S}}_{k-1}$ based on the fused 2D feature map ${\mathcal{M}}_{k-1,k}$. The feature map, which has undergone channel-wise fusion after projection, requires additional processing to extract the motion information between the two frames. To achieve this, we propose a relative pose regression module that utilizes a combination of ResNet [42] and fully connected layers. The module processes the 2D feature map $F_{BEV}$ and outputs the estimated pose transformation ${\widehat{T}}_{k-1,k}$ from ${\mathcal{S}}_k$ to ${\mathcal{S}}_{k-1}$. The detailed architecture of the regression module is illustrated in Figure 5. It primarily consists of several residual blocks followed by fully connected layers. First, a series of 2D convolutions is applied to the input feature map $F_{BEV}$. The resulting fused features are then passed through three fully connected layers to regress the translation ${\widehat{t}}_{k-1,k}$ and rotation ${\widehat{q}}_{k-1,k}$ from the source point cloud ${\mathcal{S}}_k$ to the target point cloud ${\mathcal{S}}_{k-1}$. For the rotation representation, we adopt quaternions, as they provide a more compact and efficient representation compared to rotation matrices, while being mathematically equivalent. This choice has been shown to be more effective in prior work, making quaternions the ideal regression target [10] for the relative pose module.

3.2.4. Loss Function

Existing end-to-end LiDAR odometry methods based on self-supervised learning [12,13] typically use geometric consistency between adjacent frames of point clouds for self-supervised training. These methods usually transform the source point cloud using the network-predicted relative pose to align it with the target point cloud, and then compute the difference between the transformed source point cloud and the target point cloud as the loss to supervise network training. However, the sparsity of the LiDAR point clouds and measurement errors lead to incomplete geometric consistency between adjacent point clouds, and thus, this method cannot handle the inherent alignment errors of point clouds. As shown in Figure 6, the inherent alignment errors are inconsistent in direction and magnitude across different object types. Modeling the uncertainty of point clouds is key to addressing these inherent alignment errors.

To address the impact of inherent alignment errors on network performance, this chapter proposes to model the uncertainty of point clouds using a covariance matrix. Similar to DeepLO [12], we extract geometric priors without manual labels, but our approach extends this concept through PCA-based covariance estimation to explicitly model point cloud uncertainty. This enhancement significantly improves loss robustness against alignment errors. Based on this uncertainty modeling, we design a self-supervised loss function ${\mathcal{L}}_{gt}$ consisting of a point-to-plane loss ${\mathcal{L}}_{p2n}$ and a distribution-to-distribution loss ${\mathcal{L}}_{d2d}$. These two loss functions are similar to the cost functions used in model-based point cloud registration methods [23,43]. The point-to-plane and distribution-to-distribution loss functions require the normal vectors and covariance matrices of the point clouds for computation. To accelerate the training process, the normal vectors and covariance matrices are estimated only during data preprocessing and reused during the training phase.

In calculating the loss function, the network-predicted pose transformation ${\widehat{T}}_{k-1,k}$ is first used to transform the source point cloud ${\mathcal{S}}_k$ and covariance matrix $C_k$ into the target point cloud coordinate system, resulting in the point cloud ${\tilde{\mathcal{S}}}_{k-1}$ and covariance ${\tilde{C}}_{k-1}$:

$${\tilde{\mathcal{S}}}_{k-1}=\mathrm{rot}\left({\widehat{q}}_{k-1,k}\right)\odot {\mathcal{S}}_k+{\widehat{t}}_{k-1,k},$$

(3)

$${\tilde{C}}_{k-1}=\mathrm{rot}\left({\widehat{q}}_{k-1,k}\right)C_k\mathrm{rot}{\left({\widehat{q}}_{k-1,k}\right)}^T.$$

(4)

Here, ⊙ denotes element-wise matrix multiplication. During the transformation process, only the spatial coordinates $x,y,z$ of the point cloud are considered, while the intensity values remain unchanged. The function $\mathrm{rot}(·):{\mathbb{R}}^4\to SO\left(3\right)$ represents the conversion from a quaternion to a rotation matrix. It is important to note that the transformation of the covariance matrix is influenced solely by the rotation component and is independent of translation.

To establish point correspondences between ${\tilde{\mathcal{S}}}_{k-1}$ and ${\mathcal{S}}_{k-1}$, we perform a nearest neighbor search. Specifically, for each point in the transformed source point cloud ${\tilde{\mathcal{S}}}_{k-1}$, its nearest neighbor in the target point cloud ${\mathcal{S}}_{k-1}$ is identified. This process is analogous to that used in the iterative closest point (ICP) algorithm. To improve computational efficiency, we employ a KD-Tree [44] to accelerate the nearest neighbor search. Furthermore, the KD-Tree is constructed during dataset preprocessing, which eliminates the need for reconstruction during each training iteration and thus significantly speeds up training. Based on the resulting point correspondences, the point-to-plane loss ${\mathcal{L}}_{p2n}$ and the distribution-to-distribution loss ${\mathcal{L}}_{d2d}$ are subsequently computed.

(1)

Point-to-plane loss function ${\mathcal{L}}_{p2n}$

For each point ${\tilde{s}}_b$ in the transformed source point cloud ${\tilde{\mathcal{S}}}_{k-1}$, its nearest neighbor $s_b$ in the target point cloud ${\mathcal{S}}_{k-1}$ is identified using a KD-Tree. The corresponding normal vector $n_b$, together with the point $s_b$, defines a local plane in 3D space, with $n_b$ as the surface normal at location $s_b$. By projecting ${\tilde{s}}_b$ onto this plane, the point-to-plane loss can be formulated as follows:

$${\mathcal{L}}_{p2n}={\displaystyle \frac{1}{n_k}}\sum _{b=1}^{n_k}{\left|({\tilde{s}}_b-s_b)·n_b\right|}_2^2.$$

(5)

If the normal vector $n_b$ is unavailable, the point-to-plane loss for that correspondence is omitted from the computation.

(2)

Distribution-to-Distribution Loss Function ${\mathcal{L}}_{d2d}$

For each point ${\tilde{s}}_b$ in the transformed source point cloud ${\tilde{\mathcal{S}}}_{k-1}$, its nearest neighbor $s_b$ in the target point cloud ${\mathcal{S}}_{k-1}$ is identified using a KD-Tree. Let $C_{k-1}^b$ denote the covariance matrix corresponding to $s_b$, and ${\tilde{C}}_{k-1}^b$ denote the covariance matrix associated with ${\tilde{s}}_b$. These covariance matrices characterize the local spatial uncertainty around each point. By incorporating this uncertainty into the distance metric between corresponding points, the impact of inherent alignment errors can be effectively reduced. The distribution-to-distribution loss function ${\mathcal{L}}_{d2d}$ is then formulated as follows:

$${\mathcal{L}}_{d2d}={\displaystyle \frac{1}{n_k}}\sum _{b=1}^{n_k}{(s_b-{\tilde{s}}_b)}^T\left(C_{k-1}^b+{\tilde{C}}_{k-1}^b\right)(s_b-{\tilde{s}}_b).$$

(6)

Ultimately, the self-supervised loss function ${\mathcal{L}}_{gt}$ is formulated as a weighted sum of the point-to-plane loss ${\mathcal{L}}_{p2n}$ and the distribution-to-distribution loss ${\mathcal{L}}_{d2d}$:

$${\mathcal{L}}_{gt}=\lambda ·{\mathcal{L}}_{p2n}+{\mathcal{L}}_{d2d}.$$

(7)

Since both loss terms converge independently during training, the weight $\lambda$ has minimal impact on performance during testing. In practice, the weight $\lambda$ is set to 2. The self-supervised loss encourages the neural network to predict a relative pose transformation ${\widehat{T}}_{k-1,k}$ that brings the transformed source point cloud ${\tilde{\mathcal{S}}}_{k-1}$ closer to the target point cloud ${\mathcal{S}}_{k-1}$.

4. Experiments

4.1. Dataset and Preprocessing

This paper conducts experiments on the publicly available KITTI Odometry dataset [45], which provides point cloud data captured by a Velodyne HDL-64E LiDAR sensor. To facilitate training and evaluation, the dataset is preprocessed using the following steps.

(1)

Ground Truth Trajectory Transformation

The ground truth trajectories provided by the KITTI Odometry dataset are defined in the camera coordinate system, which differs from the coordinate system of the LiDAR point clouds. Therefore, the provided ground truth trajectories cannot be directly used to evaluate the performance of LiDAR-based algorithms. To address this, the ground truth trajectories must be transformed. In this work, we utilize the extrinsic calibration parameters provided by the KITTI Odometry dataset to convert the trajectories from the camera coordinate system to the LiDAR coordinate system.

$${\widehat{T}}_{k-1,k}=T_{CL}^{-1}\left(T_{C_{k-1}}^{-1}{T}_{C_k}\right)T_{CL}.$$

(8)

In Equation (8), ${\widehat{T}}_{k-1,k}$ denotes the ground truth relative pose transformation between two consecutive frames, $T_{CL}$ is the extrinsic calibration matrix from the LiDAR coordinate system to the camera coordinate system, and $T_{C_{k-1}}^{-1}{T}_{C_k}$ represents the ground truth poses of two successive camera frames.

(2)

Normal Vector and Covariance Calculation

To facilitate the computation of the self-supervised loss during training, covariance matrices and normal vectors for each point cloud frame are precomputed during the data preprocessing stage. The covariance matrix for a given point s is calculated based on its neighboring points. Specifically, the five nearest neighbors of s within the point cloud are identified to compute the covariance matrix. A KD-Tree structure is employed to efficiently accelerate the nearest neighbor search process. The covariance matrix is computed as follows:  

$$\overline{s}={\displaystyle \frac{1}{N}}\sum _{i=1}^N{s}_i,$$

(9)

$$C={\displaystyle \frac{1}{N}}\sum _{i=1}^N(s_i-\overline{s})·{(s_i-\overline{s})}^T.$$

(10)

Here, $N=5$. Once the covariance matrix is computed, eigenvalue decomposition is applied, and the eigenvector associated with the smallest eigenvalue is selected as the normal vector $\mathit{n}$ for the point s.

(3)

Data Augmentation

To prevent the network from overfitting, random rotations are applied to augment the point cloud data. Specifically, random values following a Gaussian distribution with a mean of 0 are generated for the yaw angle. These values are then converted into a rotation matrix $R_{aug}$ representing a random rotation around the Z-axis. The random rotation $R_{aug}$ is subsequently applied to the source point cloud ${\mathcal{S}}_k$ and the associated covariance matrices $C_k$.  

$${\mathcal{S}}_k^{\mathrm{aug}}=R_{\mathrm{aug}}\odot {\mathcal{S}}_k,$$

(11)

$$C_k^{\mathrm{aug}}=R_{\mathrm{aug}}{C}_k{R}_{\mathrm{aug}}^T.$$

(12)

4.2. Implementation Details

The proposed odometry network is trained in a self-supervised, end-to-end fashion, as illustrated in Figure 1. The weights of the point cloud feature extraction network are shared across inputs. The entire network is implemented in PyTorch 1.8 within a Linux environment, with training and inference performed on an NVIDIA GeForce RTX 3090 GPU. Each point cloud frame from the KITTI dataset is first cropped to include only points within a spatial range of 140.8 m in length, 76.8 m in width, and 8 m in height. The resulting 3D region is voxelized using voxel sizes of (0.1 m, 0.1 m, and 0.2 m). Prior to training, covariance matrices and normal vectors for the input point clouds are computed using the method outlined in Section 4.1. During training, only the transformation of these precomputed normals and covariances is performed, allowing the reuse of a single computation multiple times and thereby significantly improving training efficiency. To speed up nearest neighbor searches in the self-supervised loss computation, KD-Trees are constructed for all point clouds in the dataset before training begins. The network employs the leaky_relu activation function and is optimized using the Adam optimizer, with an initial learning rate of 0.001 that decays exponentially. The training batch size is set to 16, and the model is trained for 100 epochs. The hyperparameter $\lambda$ in the self-supervised loss function ${\mathcal{L}}_{gt}$ of UnMinkLO-Net is set to 2.0. Additionally, the data augmentation technique described in Section 4.1 is applied throughout training.

4.3. Evaluation Metrics and Comparison Methods

As illustrated in Figure 1, during the testing phase, UnMinkLO-Net does not compute the self-supervised loss. Instead, it directly outputs the relative pose transformations predicted by the network as the odometry result. This chapter employs evaluation metrics consistent with those used in the KITTI Odometry benchmark [46] as the primary criteria. These metrics measure the translational and rotational errors between the estimated odometry trajectory and the ground truth. For all evaluation data, subsequences are segmented at intervals of 100 m (i.e., 100, 200,..., 800 m). The root mean square errors (RMSEs) of translation and rotation are then calculated for each subsequence. Finally, the average errors across all subsequences are computed to obtain the average translational error $t_{rel}$ and average rotational error $r_{rel}$. The average translational error is expressed as a percentage (%), where a 1% error indicates that when the robot travels 100 m, the estimated trajectory deviates by 1 m in translation from the ground truth. The average rotational error is expressed in degrees per 100 m (°/100 m), where an error of $1^{\circ }/100$ m means the estimated rotation deviates by 1 degree from the ground truth rotation over a 100 m distance.

This study conducts experiments on sequences 00–10 of the KITTI Odometry dataset, which contain ground truth poses. For fair comparison, the sequence splitting strategy used in references [12,13] is adopted, where sequences 00–08 serve as training data and sequences 09–10 are used for testing to evaluate odometry performance. The proposed method is primarily compared against existing odometry approaches based on point cloud registration and deep learning. For point cloud registration methods, this chapter compares ICP point-to-point (ICP-po2po) [47], ICP point-to-plane (ICP-po2pl) [43], and NDT point-to-distribution (NDT-P2D) [26]. For deep learning-based methods, the comparisons include DeLORA [13] and DeepLO [12], along with image-based deep learning methods such as SfMLearner [48], UnDeepVO [49], and Zhu [50]. Among these, the self-supervised end-to-end methods DeLORA and DeepLO are used as baseline methods in the comparative experiments. ICP-po2po, ICP-po2pl, and NDT-P2D are implemented using the Point Cloud Library (PCL) [51]. For DeepLO, Zhu, UnDeepVO, and SfMLearner, due to the absence of open-source code, their experimental results reported in the respective papers are directly used. Experimental results for DeLORA are obtained using the author-provided code and pretrained network weights. Since the aim of this work is to compare the accuracy of directly estimating relative pose transformations between point clouds across different odometry algorithms, none of the methods in the experiments employ loop closure detection or pose graph optimization.

4.4. Experimental Results

Table 1. Motion estimation results of different methods on the KITTI dataset ($r_{rel}$ [°/100 m], $t_{rel}$ [%]). The bolded numbers represent the optimal performance for the corresponding indicators.

Method	Training Sequences (00–08)		Sequence 09		Sequence 10
	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$
ICP-po2po [21]	3.37	6.70	2.83	6.86	4.46	8.94
ICP-po2pl [43]	2.13	4.08	2.46	5.90	3.96	6.15
NDT-P2D [26]	2.74	4.91	3.12	6.21	4.06	7.51
Zhu [50]	2.35	5.72	2.92	8.84	3.89	6.65
UnDeepVO [49]	2.55	4.54	3.61	7.01	4.65	10.63
SfMLearner [48]	4.67	28.52	3.21	18.77	3.30	14.33
DeLORA [13]	1.38	3.00	2.15	6.05	3.00	6.44
DeepLO [12]	0.87	3.68	1.95	4.87	1.83	5.02
UnMinkLO-Net (Ours)	0.91	2.51	1.87	3.03	2.01	3.79

summarizes the experimental results of various methods on the KITTI dataset. Figure 7 depicts the trajectories of ICP-po2pl, DeLORA, UnMinkLO-Net, and the ground truth on the test sequences. Figure 8 presents the trajectory projections from three different viewing angles. Figure 9 illustrates the average translational and rotational errors of ICP-po2pl, DeLORA, and UnMinkLO-Net across different driving speeds and trajectory intervals. As shown in Table 1, the self-supervised odometry method UnMinkLO-Net proposed in this chapter substantially outperforms all compared methods in trajectory estimation accuracy.

Specifically, compared to the benchmark method DeLORA, which leverages 2D convolutions and a geometric consistency loss, the proposed method reduces translational and rotational errors by 25% and 50%, respectively, on the test sequences. Relative to the benchmark DeepLO, the proposed method achieves reductions of approximately 5% and 30% in translational and rotational errors, respectively. Moreover, when compared to self-supervised visual odometry methods (SfMLearner and UnDeepVO) and classical point cloud registration techniques (ICP-po2po, ICP-po2pl, and NDT-P2D), the proposed approach consistently demonstrates significantly lower translational and rotational errors.

As shown in Figure 7 and Figure 8, compared with the learning-based DeLORA method and the registration-based ICP-po2pl method, the proposed UnMinkLO-Net achieves smaller vertical and rotational deviations in trajectory estimation. As illustrated in Figure 9, under varying driving speeds and trajectory distances, UnMinkLO-Net consistently exhibits the lowest translational and rotational errors among all compared methods. These quantitative comparisons and visualizations effectively demonstrate the superiority of the proposed method. Furthermore, the results confirm that the uncertainty-based self-supervised loss function and the 3D sparse convolution-based feature extraction module introduced in this chapter can significantly reduce trajectory estimation errors in self-supervised end-to-end odometry.

5. Discussion

5.1. Ablation Study

To investigate the contributions of the uncertainty-based loss function ${\mathcal{L}}_{gt}$ introduced in Section 3.2.4 and the 3D sparse convolution-based point cloud feature extraction module described in Section 3.2.1, this experiment combines different loss functions and point cloud processing strategies to train and evaluate UnMinkLO-Net on the KITTI dataset. First, we replace the uncertainty-based loss function in UnMinkLO-Net with the geometric consistency-based loss function ${\mathcal{L}}_{cd}$, as proposed in DeLORA [13] and DeepLO [12], and conduct experiments. Next, we substitute the 3D sparse convolution-based feature extraction module with the projection-based 2D convolutional feature extractor used in DeLORA and DeepLO.The experimental results are summarized in

Table 2. Experimental results of different loss functions and point cloud processing methods on KITTI dataset sequences 09–10 ($r_{rel}$ [°/100 m], $t_{rel}$ [%]). The bolded numbers represent the optimal performance for the corresponding indicators.

	3D Convolution, ${\mathcal{L}}_{\mathit{cd}}$		3D Convolution, ${\mathcal{L}}_{\mathit{gt}}$		2D Convolution, ${\mathcal{L}}_{\mathit{gt}}$
	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$	${\mathit{r}}_{\mathit{rel}}$	${\mathit{t}}_{\mathit{rel}}$
Average	2.41	5.42	1.94	3.41	2.52	4.26

. As shown, only when both the uncertainty-based loss function ${\mathcal{L}}_{gt}$ and the 3D sparse convolution-based point cloud feature extraction module are used does UnMinkLO-Net achieve optimal performance. This demonstrates the importance and effectiveness of these two components in improving the odometry accuracy of the proposed method.

5.2. Runtime Analysis

Since navigation tasks in mobile robotics and autonomous driving typically impose high demands on the real-time performance of odometry, this chapter analyzes the runtime of the proposed UnMinkLO-Net. Commonly used multi-line LiDAR sensors acquire point cloud data at a rate of 10 frames per second, meaning that an odometry method with an average runtime of less than 0.1 s per frame can meet real-time requirements. During the inference phase, loss functions are not computed, and the nearest neighbor search used during training introduces no additional computational overhead. The detailed runtime statistics of different comparison methods are presented in

Table 3. Runtime evaluation of different methods on KITTI dataset sequence 09.

Method	Time (ms)
ICP-po2po [21]	261
ICP-po2pl [43]	1250
NDT-P2D [26]	1723
DeLORA [13]	10
UnMinkLO-Net (Ours)	49

.

All methods are evaluated on the same computing platform to ensure fairness. As shown in the table, the average runtime of UnMinkLO-Net on the KITTI dataset is 49 ms per frame. Compared with classical point cloud registration methods such as ICP-po2po, ICP-po2pl, and NDT-P2D, the proposed method achieves a significant reduction in computational time while maintaining higher pose estimation accuracy. In addition, compared with the deep learning-based self-supervised LiDAR odometry.

6. Conclusions

This study proposes an end-to-end odometry network named UnMinkLO-Net, based on self-supervised learning. The network is capable of directly estimating the robot’s pose from LiDAR data without requiring any ground truth or annotations. The proposed odometry network mainly consists of three modules: point cloud feature extraction, bird’s-eye view (BEV)-based feature fusion, and relative pose regression.UnMinkLO-Net addresses the inherent alignment errors between consecutive point clouds by modeling uncertainty through covariance matrices. Compared with feature extraction modules based on point cloud projection and 2D convolution, the 3D sparse convolution-based module can more effectively encode the 3D geometric structure of the point cloud.

Experimental evaluations demonstrate that UnMinkLO-Net significantly improves odometry accuracy over relevant baselines, effectively overcoming limitations of existing approaches. The framework concurrently achieves high pose estimation accuracy while maintaining computational efficiency, highlighting its practical viability. While this study validates UnMinkLO-Net’s core design under standard evaluation settings, several avenues for future work remain: (1) performance validation with low-cost LiDAR sensors (e.g., 16-beam configurations); (2) robustness testing under adverse weather conditions, such as precipitation and fog; (3) assessment of generalization capabilities in diverse environments, including non-urban settings and indoor navigation scenarios. Investigating these aspects will further enhance the applicability and resilience of the proposed approach.