SASSE: Scalable and Adaptable 6-DOF Pose Estimation

TL;DR

SASSE introduces a scalable, adaptable 6-DOF pose estimation system that balances accuracy, storage efficiency, and flexibility, enabling effective localization with minimal storage and computational resources.

Contribution

The paper presents a novel localization system that simultaneously achieves sub-linear storage growth, descriptor-agnosticism, and adaptability to computational resources, a combination not previously realized.

Findings

Achieves competitive accuracy with state-of-the-art methods.

Demonstrates significantly reduced storage requirements.

Provides faster training and deployment speeds.

Abstract

Visual localization has become a key enabling component of many place recognition and SLAM systems. Contemporary research has primarily focused on improving accuracy and precision-recall type metrics, with relatively little attention paid to a system's absolute storage scaling characteristics, its flexibility to adapt to available computational resources, and its longevity with respect to easily incorporating newly learned or hand-crafted image descriptors. Most significantly, improvement in one of these aspects typically comes at the cost of others: for example, a snapshot-based system that achieves sub-linear storage cost typically provides no metric pose estimation, or, a highly accurate pose estimation technique is often ossified in adapting to recent advances in appearance-invariant features. In this paper, we present a novel 6-DOF localization system that for the first time simultaneously achieves all the three characteristics: significantly sub-linear storage growth, agnosticism to image descriptors, and customizability to available storage and computational resources. The key features of our method are developed based on a novel adaptation of multiple-label learning, together with effective dimensional reduction and learning techniques that enable simple and efficient optimization. We evaluate our system on several large benchmarking datasets and provide detailed comparisons to state-of-the-art systems. The proposed method demonstrates competitive accuracy with existing pose estimation methods while achieving better sub-linear storage scaling, significantly reduced absolute storage requirements, and faster training and deployment speeds.

Figures

Tables

Table 1. TABLE I : Experimental Results on the 7-Scenes Dataset. For SASSE, we provide both the results before and after PGO.

Scene	#Train	#Test	PoseNet17 [15]	PoseNet-LSTM [34]	VidLoc [5]	MapNet+PGO [3]	SCoRe Forest [30]	SASSE	SASSE + PGO
Chess	4000	2000	0.13m, 4.48°	0.24m, 5.77°	0.18m, NA	0.09m, 3.24°	0.03m, 0.66°	0.27m, 0.41°	0.19m, 0.41°
Fire	2000	2000	0.27m, 11.30°	0.34m, 11.9°	0.26m, NA	0.20m, 9.04°	0.05m, 1.50°	0.38m, 0.37°	0.28m, 0.37°
Heads	1000	1000	0.17m, 13.00°	0.21m, 13.7°	0.14m, NA	0.12m, 8.45°	0.06m, 5.50°	0.15m, 0.32°	0.11m, 0.32°
Office	6000	4000	0.19m, 5.55°	0.30m, 8.08°	0.26m, NA	0.17m, 5.15°	0.04m, 0.78°	0.38m, 0.51°	0.38m, 0.51°
Pumpkin	4000	2000	0.26m, 4.75°	0.33m, 7.0°	0.36m, NA	0.22m, 4.02°	0.04m, 0.68°	0.38m, 0.33°	0.32m, 0.33°
Kitchen	7000	5000	0.23m, 5.35°	0.37m, 8.83°	0.31m, NA	0.20m, 4.93°	0.04m, 0.76°	0.44m, 0.52°	0.31m, 0.52°
Stairs	2000	1000	0.35m, 12.40°	0.40m, 13.7°	0.26m, NA	0.27m, 10.57°	0.32m, 1.32°	0.33m, 0.51°	0.25m, 0.34°

Table 2. TABLE II : Experimental Results on the Cambridge Landmarks Dataset.

Scene	#Train	#Test	Active Search [27]	PoseNet [16]	Bayesian PoseNet [14]	PoseNet-LSTM [34]	PoseNet17 [15]	SASSE	SASSE + PGO
Great Court	1533	761	–	–	–	–	6.83m, 3.47°	18.3m, 0.53°	12.5m, 0.53°
King’s College	1220	343	0.42m, 0.55°	1.66m, 4.86°	1.74m, 4.06°	0.99m, 3.65°	0.88m, 1.04°	3.18m, 0.14°	1.61m, 0.14°
Old Hospital	895	182	0.44m, 1.01°	2.62m, 4.90°	2.57m, 5.14°	1.51m, 4.29°	3.20m, 3.29°	4.18m, 0.20°	2.97m, 0.20°
Shop Facade	231	103	0.12m, 0.40°	1.41m, 7.18°	1.25m, 7.54°	1.18m, 7.44°	0.88m, 3.78°	2.28m, 0.21°	1.59m 0.21°
St Mary’s Church	1487	530	0.19m, 0.54°	2.45m, 7.96°	2.11m, 8.38°	1.52m, 6.68°	1.57m, 3.32°	4.38m, 0.23°	2.91m 0.23°
Street	3015	2923	0.85m, 0.83°	–	–	–	20.3m, 25.5°	26.61m, 1.11°	23.13m, 1.11°

Table 3. TABLE III : SASSE’s absolute storage (in comparison to other methods) to achieve the localization results shown in Table  I and Table  II . Top: 7-Scenes dataset; Bottom: Cambridge Landmark dataset. Our method requires much smaller absolute storage, while the translation and rotation errors are comparable. Note that the storage for the VLAD’s dictionary is also included.

	Chess	Fire	Heads	Office	Pumpkin
SASSE	9.8 MB	7.8 MB	7.5 MB	12.7 MB	15.9 MB
BTRF [19]	130.5 MB	110.8 MB	146.5 MB	144.8 MB	100.2 MB
MapNet [3]	256 MB

Table 4. TABLE IV : Training time (in minutes) for several sequences in the 7-Scene datasets. For SASSE, the time for feature extraction (VLAD) is also included. BTRF is executed based on the default parameters provided in the paper.

	Chess	Fire	Heads	Office	Pumpkin
SASSE	5.56	3.50	2.0	7.65	6.15
BTRF [19]	41.45	40.45	35.35	47.23	44.50

Equations

$${\mathbf{p}}_i=\left[{\mathbf{q}}_i{\mathbf{t}}_i^t\right]=\left[q_i^a,q_i^b,q_i^c,q_i^d,t_i^1,t_i^2,t_i^3\right]$$

$$h({\mathbf{p}}_i)=\left[h(q_i^a)h(q_i^b)h(q_i^c)h(q_i^d)h(t_i^1)h(t_i^2)h(t_i^3)\right]$$

$$\underset{\mathcal{C}\subseteq \{1,\dots ,7b\},|\mathcal{C}|=r}{\min }{\Vert \mathbf{Y}-{\mathbf{Y}}_{\mathcal{C}}{\mathbf{Y}}_{\mathcal{C}}^{†}\mathbf{Y}\Vert }_F,$$

$$\mathbf{Z}={\mathbf{Y}}_{\mathcal{C}}^{†}\mathbf{Y}.$$

$$\underset{\mathbf{W}\in {\mathbb{R}}^{d\times r}}{\min }\Vert \mathbf{XW}-{\mathbf{Y}}_{\mathcal{C}}{\Vert }_F^2+\lambda \Vert \mathbf{W}{\Vert }_F^2,$$

$${\mathbf{W}}^{\ast }={\left({\mathbf{X}}^T\mathbf{X}+\lambda \mathbf{I}\right)}^{-1}{\mathbf{X}}^T\mathbf{Y}.$$

$${\tilde{\mathbf{y}}}_{\mathcal{C}}=f_r(\mathbf{x})={\mathbf{W}}^T\tilde{\mathbf{x}}$$

$$\tilde{\mathbf{y}}=\mathrm{sign}\left({\tilde{\mathbf{y}}}_{\mathcal{C}}^T\mathbf{Z}\right),$$

$$S=8(dr+7rb)=8r(d+7b),$$

$$S=8\big{(}kr(d+7b)+(k-1)(d+1)\big{)},$$

$$\underset{\begin{array}{c}{\mathbf{t}}_i,{\mathbf{t}}_j\in {\mathbb{R}}^3\\ {\mathbf{R}}_i,{\mathbf{R}}_j\in SO(3)\end{array}}{\min }\sum _{\begin{array}{c}i,j=1,\\ i\ne j\end{array}}^T{L}_{ij}+\sum _{i=1}^T{L}_i^{\prime },$$

$$L_{ij}={\Vert {\mathbf{t}}_{ij}-{\mathbf{R}}_i^T({\mathbf{t}}_j-{\mathbf{t}}_i)\Vert }^2+d_R^2\left({\mathbf{R}}_{ij},{\mathbf{R}}_i^T{\mathbf{R}}_j\right)$$

$$L_i={\Vert {\mathbf{t}}_i-{\hat{\mathbf{t}}}_i\Vert }^2+d_R^2\left({\mathbf{R}}_{ij},{\mathbf{R}}_i^T{\mathbf{R}}_j\right)$$

$$\underset{{\mathbf{t}}_i,{\mathbf{t}}_j}{\min }\sum _{ij}{\Vert {\mathbf{t}}_j-{\mathbf{t}}_i-{\hat{\mathbf{R}}}_i{\mathbf{t}}_{ij}\Vert }^2+\sum _i{\Vert {\mathbf{t}}_i-{\hat{\mathbf{t}}}_i\Vert }^2,$$

Full text

I Introduction

In recent years, the emergence of autonomous driving, robotics and augmented reality (AR) has relied in significant part on strong advances in the underlying localization and mapping algorithms [7]. Several localization and mapping systems have achieved the ability to accurately operate in a wide variety of different visual conditions such as day-night, weather, and seasonal changes in the environment [1]. By learning good representations for the scenes together with efficient encoding and hashing mechanisms, a few state-of-the-art localization systems are able to provide not only the rough location estimate, but also the accurate full six degree-of-freedom (6-DOF) camera poses [16, 3, 32].

While improving common metrics such as accuracy, precision and recall has been a primary focus of recent works on visual localization, the storage cost (and often correlated compute cost) of a system is also a key factor that needs to be carefully considered as the scale of training data grows. It becomes even more critical when a localization system is designed to deploy onto lightweight robots or AR devices with limited storage budgets. Additionally, in several long-term localization applications [10] where the input data constantly grow over time, the storage limits and the associated computational burdens become a bottleneck that impede the real-time performance of the overall system. Developing more efficient localization algorithms with less absolute storage consumption and better storage scalability is desirable because it offers a number of beneficial outcomes in general: more computational resources are spared for other system competencies, and the system can opt to cheaper, lighter, and less power hungry hardware. Within certain storage and computational budgets, a localization system has the options to either retaining the desired localization performance with less compute, or to use the saved resources to further improve localization accuracy. These benefits apply regardless of the absolute storage and computational resources available, whether it be a low power embedded system on a micro-drone or mini-robot, or a high-end autonomous driving system.

Although the precision and recall of existing localization algorithms have been significantly improved in recent years, their storage scalability has not been as thoroughly investigated. Our paper tackles the storage scalability issue by proposing a novel encoding algorithm that provides an accurate 6-DOF localization with significantly less storage footprint compared to existing approaches. Our method achieves significantly sub-linear storage growth, i.e., its required storage scales significantly sub-linearly with the size of the available input to maintain a certain degree of accuracy. Furthermore, by employing a suite of fast optimization techniques, the training and testing time of our algorithm is also substantially faster than existing approaches, which makes it suitable for many real-time applications.

The proposed approach also has longevity advantages compared with existing techniques. Despite the remarkable localization results achieved by existing pose regression methods such as PoseNet [16] or MapNet [3], the ability of these networks to cope with extreme changes in visual conditions (e.g., day-night, weather, and seasons) is still less satisfactory, as empirically shown in [28]. A large body of work has been devoted to improve the robustness to drastic environmental changes by developing effective global image descriptors that provide more informative representations of the scenes. It would be very beneficial if the cutting-edge image descriptors can be utilized by the state-of-the-art localization methods for 6-DOF pose estimation. However, taking PoseNet and its variants [16, 15] as examples, due to the fixed network structures, transferring and integrating of those advanced image descriptors (e.g., LoST [8]) into the networks is not trivial, not to mention the fact that, for every type of feature descriptor, a new variant of the network needs to be trained and its hyper-parameters must be carefully tuned in order to achieve a good performance. Our proposed encoding mechanism does not have the same limitation. It allows the flexible use of existing image descriptors, from the traditional hand-crafted features such as VLAD [13] and Fisher Vector [20] to recent state-of-the-art deep features such as NetVLAD [1], DenseVLAD [25] and LoST [8]. Hence, our method can effectively handle large environmental changes of the scenes while providing highly accurate 6-DOF localization results.

Our method also provides an easy mechanism for tuning the deployment size by adjusting two hyper-parameters during the training process, allowing adjustment of the trade-off between storage and performance. In contrast, since the network structure of PoseNet and its variants are fixed, the configuration of their required storage is not easily modified. Although recent network compression techniques [38, 36] can be employed as a post-processing step to reduce the storage requirement, these techniques are usually complicated to use and require extra fine-tuning efforts for the compressed network to achieve comparable performance on the target training set.

Contributions In summary, the contributions of our work can be stated as follows:

• •

We propose a novel storage-efficient encoding algorithm for 6-DOF localization (SASSE) using a novel adaptation of multiple-label learning techniques. The required storage of our system is order of magnitudes lower than for existing methods such as PoseNet [16] or MapNet [3] while the localization results are comparable to these approaches.

• •

Our SASSE system allows the storage requirement to be easily tuned to suit the application at hand, enabling the system to be deployed onto a large variety of systems with different storage budgets.

• •

The training and inference algorithms of SASSE are simple and easy to implement and the training and inference processes are fast. Our approach provides real-time performance (approximately $7$ms/frame) without the need of GPUs, and is even faster than a GPU implementation of MapNet [3].

• •

Our system is agnostic to the input data, i.e., it is compatible with different types of image descriptors such as VLAD [13], Fisher [20], Democratic Embedding [12], NetVLAD [1]. To the best of our knowledge, we are the first to propose a method that allows state-of-the-art descriptors such as NetVLAD to be used for pose regression.

• •

We provide an empirical analysis on the scalability of our system, where we empirically show that SASSE achieves sub-linear storage growth as the number of training frames increases.

Collectively, the contribution of this research is for the first time that all these desirable properties have been achieved simultaneously.

II Related Work

Visual localization has become a mature research topic in recent years. A detailed survey can be referred to [18]. Generally speaking, existing methods for visual localization can be categorized into two classes of methods, namely, image retrieval based localization and accurate 6-DOF localization.

The underlying mechanism behind retrieval-based localization methods is to learn a good image representation, which can then be used to measure the similarity between images. In the ideal case, the image of the same scene under different weather or lighting conditions should admit the same representation. In practice, the representations are not the same, however, we expect them to be as close as possible, so that the localization from a query image can be done by finding the nearest neighbors of its representation in the database. At its core, a global image descriptor can be generated by aggregating hand-crafted features, such as SIFT [17] or ORB [24], to a global descriptor vector. The aggregating step can be done using the bag-of-word model, or the well-known VLAD [13] and its variants [20, 12]. Apart from conventional hand-crafted features, deep neural networks are also extensively utilized to obtain global image descriptors. Several good deep-network based descriptors have been proposed in the literature, such as NetVLAD [1], DenseVLAD [31]. Recently, fine-tuning schemes [23] have also been proposed which have achieved significant improvements in performance.

On the other hand, 6-DOF localization methods aim to provide an accurate pose for a query image, including the camera location and its orientation with respect to the global environment. Traditional method builds the 3D point clouds for the scene using several structure-from-motion frameworks such as COLMAP [29] or VisualSFM [35]. At the query stage, an image is localized by solving for the 2D-3D matching problem to register the image into the point cloud database [26]. In a wide operating environment, the number of 3D points can extremely large, thus finding the optimal 2D-3D matching is almost intractable. To mitigate this, several voting schemes [37] have been developed. However, with badly contaminated data, the execution time of many random voting approaches may not be suitable for real-time localization. Active Search [27] has proposed a prioritized matching approach utilizing vocabulary trees to significantly speed up the query time. To exploit the power of deep networks for 6-DOF localization, PoseNet proposes to train a network that directly regress the 6-DOF pose for a query image. During the training process, the image representations are implicitly learned, allowing PoseNet to accurately regress 6-DOF poses for new images in real time without explicitly performing 2D-3D matching. Several variants of PoseNet [15, 34] and MapNet [3] have been proposed since then and have been shown to achieve better results. The main drawback of deep-network based approaches is that the localization results are not as accurate as traditional 2D-3D matching frameworks, as shown in [28]. Tree-based methods [30] have also been shown to perform well for several indoor datasets.

III Approach

In this work, we assume that 6-DOF poses of the training images are readily available. Given $N$ images represented by a set $\mathcal{D}=\{(\mathbf{x}_{i},\mathbf{p}_{i})\}_{i=1}^{N}$, where $\mathbf{x}_{i}\in\mathbb{R}^{d}$ is an image representation of image $i$, and $\mathbf{p}_{i}$ denotes its corresponding pose. As previously mentioned, $\mathbf{x}_{i}$ can be selected from a wide variety of global image descriptors [13, 1, 22, 20] and thus its dimensionality $d$ depends on the representation of choice. Our goal now is to learn a function $f(\cdot)$ such that, given a query image $\tilde{\mathbf{x}}$, its pose $\tilde{\mathbf{p}}$ can be best estimated by $f(\cdot)$, i.e., $\tilde{\mathbf{p}}=f(\tilde{\mathbf{x}})$.

III-A Pose Representation

Following other works on pose regression [16, 3], for each training image $\mathbf{x}_{i}$, we represent its camera center by a three dimensional vector $\mathbf{t}_{i}=\left[t^{1}_{i},t_{i}^{2},t_{i}^{3}\right]\in\mathbb{R}^{3}$ and its rotation by a quaternion $\mathbf{q}_{i}$, which is a vector containing 4 real numbers: $\mathbf{q}_{i}=\left[q_{i}^{a},q_{i}^{b},q_{i}^{c},q_{i}^{d}\right]$. Thus, the pose $\mathbf{p}_{i}$ of an image can be represented as a $7$-dimensional real vector:

[TABLE]

III-B Binary Representation of a Pose Vector

Before training our encoder, we first transform the pose vectors described in (1) into their corresponding binary representations. While several types of representation exist, we employ the simple approach of converting each element in the pose vector into a binary string, then concatenate the strings into one longer binary vector to represent the pose. More specifically, let $h(z)$ represent the operation that converts a real-valued number $z$ into its binary floating point representation. Thus, $h(z)\in\{0,1\}^{b}$, where the value of $b$ can be $16$, $32$, or $64$ depending on whether half, single, or double precision is used. For the ease of notation, we also denote $h(\mathbf{p})$ to be the operation that converts a pose vector $\mathbf{p}$ into its binary representation:

[TABLE]

It can be seen that $h(\mathbf{p}_{i})$ is a binary vector that has the length of $7b$, i.e., $h(\mathbf{p}_{i})\in\{0,1\}^{7b}$. The inverse operation of $h(\cdot)$, i.e., converting from a binary string into its original real-value representation, is denoted by $h^{-1}(\cdot)$.

We would like to remark that the reason for converting the pose vector $\mathbf{p}_{i}$ into binary is for the user to explicitly choose the required encoding precision for the poses (by changing the value of $b$). As discussed in Section III-E, this will help to further reduce the absolute storage required. In our experiments, setting $b=16$ works well for most of the cases without any significant loss in accuracy compared to the experiments with $b=32$ or $b=64$.

III-C Binary Learning for Pose Regression

Henceforth, for brevity, we denote by $\mathbf{X}\in\mathbb{R}^{N\times d}$ the matrix containing the training data $\{\mathbf{x}_{i}\}_{i=1}^{N}$, where each row of $\mathbf{X}$ represents a feature vector $\mathbf{x}_{i}$. Similarly, let $\mathbf{Y}\in\{0,1\}^{N\times 7b}$ be the binary matrix that stores the poses of the training data, where each row of $\mathbf{Y}$ is a binary vector, i.e., $\mathbf{y}_{i}=h(\mathbf{p}_{i})$. The problem now becomes learning a function $f_{b}(\cdot):\mathbb{R}^{d}\mapsto\{0,1\}^{7b}$ such that given a query vector $\tilde{\mathbf{x}}$, the value of $h(\tilde{\mathbf{x}})$ can be best predicted by $h(\tilde{\mathbf{x}})=f_{b}(\tilde{\mathbf{x}})$. After obtaining $h(\tilde{\mathbf{x}})$, its pose $\tilde{\mathbf{p}}$ can be computed easily using the inverse operation $h^{-1}(\cdot)$. In other words, the predicted pose is $\tilde{\mathbf{p}}=h^{-1}(f_{b}(\tilde{\mathbf{x}}))$.

The overall learning algorithm of SASSE consists of two main steps, namely, learning the embedding of binary matrix and learning the regression in the reduced label space, which will be discussed in the following.

III-C1 Embedding of Label Matrix

This step allows the binary label matrix $\mathbf{Y}$ to be embedded into a new domain with smaller dimensionality, thus it can also be referred to as the dimension reduction step. As discussed in Section III-E and experimentally shown in Section IV-D1, this step enables the required storage to be easily adjusted based on the applications’ requirements.

The main intuition behind this embedding step is to select a subset containing $r$ columns of $\mathbf{Y}$ ($r\leq 7b$) such that the sub-matrix $\mathbf{Y}_{\mathcal{C}}\in\mathbb{R}^{N\times r}$ formed by the $r$ selected columns spans $\mathbf{Y}$ as much as possible. Mathematically, let $\mathcal{C}\subseteq\{1,\dots,7b\}$ represent the set containing the indexes of the selected columns with $|\mathcal{C}|=r$, the embedding step can be expressed as the following problem:

[TABLE]

where the notation † denotes the pseudo inverse of a matrix. The most straight-forward approach to solve (3) is to enumerate all possible subsets of size $r$ from the index set $\{1,\dots,7b\}$ and return the subset that minimizes the objective of (3). However, this is almost intractable when the number of columns in $\mathbf{Y}$ is large. To alleviate this difficulty, there exist several alternative approaches to solve (3) sub-optimally. In our work, we employ the method of exact subset sampling, which is inspired by [2]. More details are provided in the supplementary material.

After solving (3) to obtain the matrix $\mathbf{Y}_{\mathcal{C}}$, we compute the projection matrix $\mathbf{Z}$

[TABLE]

This matrix will be stored for the pose prediction process as it acts as a projection matrix from the reduced label space to the original space. See details in Section III-D.

III-C2 Label Regression in the Reduced Space

After embedding the original binary label matrix into a smaller label space, i.e., every label vector $\mathbf{y}_{i}$ in the training dataset now corresponds to a reduced label vector $\mathbf{y}_{\mathcal{C}i}$, the next step is to learn a regressor in this reduced label space. Particularly, we now aim to learn a function $f_{r}(\cdot):\mathbb{R}^{d}\mapsto\mathbb{R}^{r}$ such that given a query vector $\mathbf{\tilde{x}}$, its reduced label $\tilde{\mathbf{y}}_{\mathcal{C}}$ is best predicted by $f_{r}(\cdot)$. Once $\tilde{\mathbf{y}}_{\mathcal{C}}$ is computed, we can project it back to the original label space then obtain the binary label vector $\tilde{\mathbf{y}}$; details are discussed in Section III-D.

In this work, we propose to learn $f_{r}(\cdot)$ by solving a Ridge Regression problem, where the goal is to find a parameter matrix $\mathbf{W}\in\mathbb{R}^{d\times r}$ that minimizes the following objective:

[TABLE]

where $\lambda>0$ is a regularization parameter. In our experiments, it is observed that the performance of SASSE is not sensitive to the parameter $\lambda$ so we fix $\lambda=0.1$ throughout all the experiments.

One advantage our proposed learning scheme is that (5) admits a closed-form solution $\mathbf{W}^{*}$, which can be stated as:

[TABLE]

Therefore, the learning of $f_{r}(\cdot)$ can be solved efficiently using matrix operations as expressed in (6).

III-D 6-DOF Camera Pose Prediction

It can now be seen that the task of learning the original pose predictor $f(\cdot)$ comprises two sub-tasks, namely, learning the projection matrix $\mathbf{Z}=\mathbf{Y}_{\mathcal{C}}^{\dagger}\mathbf{Y}$ and then learning the set of regression weights $\mathbf{W}$ as discussed in Sections III-C1 and III-C2, respectively. Therefore, given a query image represented by the feature vector $\mathbf{\tilde{x}}\in\mathbb{R}^{d}$, its pose $\mathbf{\tilde{p}}$ can be predicted by executing the following steps

• •

Obtaining the reduced label $\tilde{\mathbf{y}}_{\mathcal{C}}\in\mathbb{R}^{r}$ using $f_{r}(\cdot)$

[TABLE]

• •

Projecting of $\tilde{\mathbf{y}}_{\mathcal{C}}$ back into the original binary label domain to obtain $\tilde{\mathbf{y}}\in\{0,1\}^{7b}$:

[TABLE]

where $\mathrm{sign}(a)=1$ if $a>0$ and [math] otherwise. We simply use the $\mathrm{sign}$ operation to obtain the binary label vector.

• •

Retrieving the 6-DOF pose: from the predicted vector $\tilde{\mathbf{y}}$, the pose $\mathbf{\tilde{p}}$ can be easily obtained by performing the inverse operation $h^{-1}(\cdot)$, i.e., converting the binary vector $\tilde{\mathbf{y}}$ to a real-valued vector containing the corresponding rotation and translation.

III-E Absolute Storage Analysis

Based on our previous discussions, the parameters that needs to be stored include:

• •

Regression matrix $\mathbf{W}\in\mathbb{R}^{d\times r}$: as discussed in Section III-C2 and Section III-D, this matrix captures the mapping between the original feature space to the reduced label space. As can be observe from the dimension of $\mathbf{W}$, its storage is independent of the database size $N$.

• •

Projection matrix $\mathbf{Z}\in\mathbb{R}^{r\times 7b}$: this serves as the projection matrix that allows recovery of the original binary label from its corresponding reduced vector. Similar to $\mathbf{W}$, the size of $\mathbf{Z}$ does not depend on $N$.

From the analysis above, it is clear that in order to adjust the amount of storage required, one only needs to adjust the value of $r$, which is the dimension of the reduced label space, and $b$, which is the precision of the encoded poses. The total amount of required storage (in bytes) can then be expressed as:

[TABLE]

assuming that each real number requires $8$ bytes (64 bits). Refer to Section IV-D1 for experiments on how varying $r$ affects the absolute storage and the localization accuracy.

III-F Partition of Training Data

Our proposed encoding algorithm is now functional for pose regression. However, as a typical characteristic of many machine learning algorithms, when the number of training data grows drastically, this vanilla version is prone to under-fitting. To mitigate the under-fitting issue, inspired by the observation that the visual data for applications such as autonomous driving tends to be partitioned into different clusters - where image representations in each cluster are similar and can be easily classified, we propose to further advance the inference accuracy by introducing an additional clustering process. Particularly, we firstly partition the original training data into $k$ clusters $\mathcal{D}_{1},\dots\mathcal{D}_{k}$, where $\mathcal{D}_{1}\cup\dots\cup\mathcal{D}_{k}=\mathcal{D}$ and $\mathcal{D}_{i}\cap\mathcal{D}_{j}=\emptyset;\forall i\neq j$. Then, $k$ different pose regressors $\{f^{i}(\cdot)\}_{i=1}^{k}$, where $f^{i}(\cdot)$ takes $\mathcal{D}_{i}$ as its training data, are trained using the procedure described in Section III-C.

At the inference stage, in order to predict the correct pose from a given query vector, the algorithm needs to select one of the $k$ possible predictors to use. This is achieved through an additional classifier $f_{c}(\cdot)$, where $f_{c}(\mathbf{\tilde{x}})$ provides the cluster index $j$ to which $\mathbf{\tilde{x}}$ belongs, so that the corresponding predictor $f^{j}(\cdot)$ can then be employed to obtain the pose. We employ a Support Vector Machine (SVM) to train $f_{c}$, where the input data for the SVM is the original dataset $\mathcal{D}$, while the training label of each data point is the index of the corresponding cluster to which it is assigned.

When clustering is applied, the absolute storage of SASSE must be computed as the total storage required by $k$ different regressors $f^{i}(\cdot)$, with the additional storage required to store the parameters of $f_{c}(\cdot)$. Specifically, as $f_{c}(\cdot)$ is a linear classifier with $k$ classes, $k-1$ hyperplanes need to be stored, and each hyperplane is of $d+1$ dimensions. Together with (9), the total required (in bytes) storage now becomes

[TABLE]

where $r$ is the embedding size as discussed in Sec. III-C1, and $b$ is the precision described in Sec. III-B

From (10), it can be observed that besides $r$, the number of clusters $k$ is the additional parameter that can be tuned to achieve the desired storage. Since the dimension $d$ of the feature vector can also impact the storage, one can further reduce the storage by choosing a type of feature with smaller dimensionality. However, to demonstrate the impact of the two main hyper-parameters in our algorithm, we use the same value of $d$ throughout all experiments.

III-G *Pose Correction with Pose Graph Optimization (PGO) *

We have explained the major techniques underpinning the SASSE, which demonstrates good localization results in the experiment section. Additionally, in some applications where relative poses among consecutive query frames are also made available, the absolute poses of each frames can be further refined by incorporated the relative poses into a PGO framework.

Let us denote by $\hat{\mathbf{t}}_{i}$ and $\hat{\mathbf{R}}_{i}$ the predicted camera center and orientation of frame $i$, respectively. Assume that the relative poses between frames $i$ and $j$, denoted by $\mathbf{t}_{ij}$ and $\mathbf{R}_{ij}$, is provided by an off-the-shelf Visual Odometry (VO) framework [6]. The goal of PGO is to find the optimal poses $(\mathbf{t}^{*}_{i},\mathbf{R}^{*}_{i})$ and $(\mathbf{t}^{*}_{j},\mathbf{R}^{*}_{j})$ to minimize the following objective function [4]:

[TABLE]

where the functions $L_{ij}$ and $L^{\prime}_{i}$ are defined as follows

[TABLE]

[TABLE]

Here, $d_{R}$ denotes the rotation error between the two rotation matrices and $T$ represents the number of frames in a window that needs to be optimized. In our experiments, PGO is executed for windows containing $T=5$ to $10$ frames.

While several standard PGO solvers [9] can be employed to solve (11), our empirical results show that SASSE can produce very accurate orientation, where most of the rotation errors are less than $1\degree$. Therefore, we simplify the solving of (11) by assuming that $\mathbf{R}^{*}_{i}=\hat{\mathbf{R}}_{i}$, i.e., the optimal poses are provided by SASSE. Thus, our PGO problem boils down to solving the convex least squares problem

[TABLE]

which can be solved using a closed-form solution.

IV Experimental Results

In this section, we conduct several experiments to evaluate the performance of our proposed method on several commonly used datasets. We also analyze the performance of SASSE under different parameter settings, and provide detailed information about the absolute storage required as well as its scalability.

IV-A Datasets and Evaluation Metrics

Two popular public datasets are used in our experiments: 7-Scenes Dataset [30] 111https://www.microsoft.com/en-us/research/project/rgb-d-dataset-7-scenes/, which consists of RGB-D captures of seven different indoor scenes, and Cambridge Landmarks dataset [16], which contains video frames of 5 different scenes under large scale outdoor urban settings. Although depth information are provided in these datasets, we only make use of RGB images and their associated poses to train our system.

To obtain global image descriptors for the training and testing images, we employ the VLFeat toolbox [33] to extract the VLAD [13] descriptors, where the number of codeword is set to $8$. Unless stated otherwise, VLAD is used throughout all experiments. In Section IV-E, the performance of our system with different types of feature will also be evaluated.

Our method is implemented in MATLAB R2018a. The source code of our method can be accessed at http://tiny.cc/4ezt2y and will be released with the publication of this paper. All experiments are executed on an Ubuntu Machine with an eight-core 4.20GHz CPU and 32GB of RAM.

Following other work on 6-DOF pose localization [16, 3], we report the median of translation and rotation errors (in meters and degree, respectively). More details on metrics for rotation can be referred to [11].

IV-B Localization Accuracy and Required Storage

In order to demonstrate the localization ability of our framework, we first report the median of translation and rotation errors on the 7-Scenes and Cambridge Landmark datasets, together with theirs required storages. A detailed study on the effect of parameters will be presented in latter sections.

Table I and Table II shows the results of SASSE and other methods on the two benchmarked datasets. Observe that the translation errors obtained by our method is very competitive compared to MapNet and several PoseNet’s variants. Note that the results of SCoRe Forest [30] is trained with RGB-D data. Notably, the rotation provided by our method outperforms the results from other methods, which demonstrates the ability to accurately regress poses of our system. For most of the sequences, the rotation error achieved by our system is less than $1\degree$, while the errors of PoseNet and MapNet are much larger.

Table III shows the absolute storage required by our method to obtain the results shown in Table I and Table II. For SASSE, the storage of VLAD’s codebook (for feature extraction during inference) is also included. Our absolute storage footprint is significantly smaller compared to PoseNet [16], MapNet [3], and tree-based approaches such as BTRF [19] which are among the state-of-the-art methods for 6-DOF pose regression. Note that in contrast to the fixed network structures of PoseNet or MapNet, SASSE allows the flexible configuration of the training process. Therefore, we are able achieve much smaller absolute storage while maintaining a competitive performance.

IV-C Testing and Training Time

Besides the ability to encode a large amount of training data into a compact set of parameters with very small storage footprint, our design allows the testing time to be significantly shorter than current approaches. This is shown in Figure 3, where we plot the query time of SASSE in comparison with MapNet [3] and BTRF [19]. As can be seen in this figure, SASSE runs significantly faster than MapNet and BTRF due to the fact that the pose inference in SASSE requires only simple matrix operations. On the other hand, in order to achieve good results, tree-based methods such as BTRF requires an additional step of performing 2D-3D matching to obtain the pose leading to the increase in total run time. Note that we execute MapNet on GPU to report the time Figure 3, while our method only runs on CPU with a MATLAB implementation.

Moreover, the time required to train our system is also faster than other methods. Table IV reports the training time of our system for several sample sequences in the 7-Scenes dataset. Note that we have also included the time needed to extract the VLAD descriptors. Observe that SASSE requires less than 10 minutes for all the datasets, while the training time for BTRF is around 45 minutes. It is also well-known that the training time for deep-network based approaches such as PoseNet requires much higher training time, thus we omit them from Table IV.

IV-D Performance under Different Parameter Settings

In this section, we study the performance of the system under different parameter settings. We focus on the two main parameters that can be adjusted to achieve the desired storage, namely, the embedding size $r$ and the number of clusters $k$.

IV-D1 Embedding Size $r$

In Figure 4, we plot the translation and rotation error of SASSE under different values of $r$ with the number of cluster $k$ is fixed to $1$. Note that the values of required storage are also displayed on the bottom row of x-axis. As can be seen, SASSE performs well even for small values of $r$, demonstrating the effectiveness of the embedding step. When $r$ increases, the performance becomes even better, as more information is retained during the training process. This behavior can be observed for all sequences in the two datasets.

IV-D2 Number of Clusters $k$

Next, we study the effect of the clustering in a similar manner. Figure 5 plots the performance of SASSE across several values of $k$ with a fixed value of $r=50$. When the number of clusters increases the performance improves. However, when we continue to increase $k$, the decrease in errors is no longer significant. This shows that the good performance of SASSE relies mainly on the learning algorithm discussed in Section III-C, while the clustering step is for the purpose of preventing under-fitting.

IV-E Performance under different types of image descriptor

SASSE, as discussed, can be trained with different types of image descriptors. Figure 6 plots the cumulative translation errors for two sequences (King’s College and Chess) with three commonly used descriptors: VLAD [13], NetVLAD [1] and Fisher [20], where it can be observed that the performances of SASSE with these descriptors are comparable. Although the CNN-based descriptor NetVLAD shows a slight increase in performance, the storage of its network for feature extraction during inference will also increase the absolute storage. On the other hand, traditional hand-crafted features can also provide competitive results with much less storage.

IV-F Storage Scalability

To test the scalability of SASSE, we investigate the required storage when the number of training data increases. We extract $N$ training and $N$ testing data points from the Heads sequence, with $N$ increases from $300$ to $1000$. For each value of $N$, we run the SASSE with different sets of parameters and report the smallest amount of storage required such that the median of translation errors is less than $0.2m$ and the median of rotation errors is less than $5.0\degree$. The storage is compared against BTRF [19]. To adjust the required storage for BTRF, we change the number of regression trees and the number of levels in each tree. Figure 7 plots the results. To analyze the dependence of total storage $S$ on database size $N$, we fit a function of the form. $S=N^{a}+b$ to the data points in Figure 7. The plots of these functions are also shown, where the $(a,b)$ tuples for SASSE and BTRF are $(0.28,-4.8)$ and $(0.4,-2.5)$, with the mean squared errors (MSE) of 0.05 and 0.07, respectively.

Observe that both SASSE and BTRF show the tendency to scale sub-linearly with the number of training data. However, since $S_{\text{SASSE}}=O(N^{0.28})$, while $S_{\text{BTRF}}=O(N^{0.4})$, it is evident that SASSE achieves better scalability in terms of required storage due to our efficient encoding method. BTRF, on the other hand, needs to store feature information at each leaf node, requiring larger storage footprint. In our experiments, at least $3$ trees are required, while the number of levels in each tree must be greater than $8$ in order for BTRF to achieve good localization results.

V Conclusion and Future Work

In this paper, we have presented a novel storage-efficient algorithm for 6-DOF localization (SASSE). While providing competitive localization results compared to existing state-of-the-art approaches, our method has several additional advantages: it requires a much smaller storage footprint, has a more significantly sub-linear storage scaling profile, is agnostic to image descriptor type and hence can easily utilize descriptors suited to the specific application without re-training or learning, achieves faster training and deployment speeds, and is easily adapted to suit a wide range of computational resource scenarios.

In the future work, SASSE could be extended for applications where 6-DOF poses are not readily available. In such scenarios, one can consider the pose contains only 1-DOF single translation (to indicate to current location) and the same encoding technique as SASSE can be applied. Furthermore, the learning of binary labels can be improved by employing recent developments in multiple-label classification research such as tree learning approaches [21] or improving the embedding techniques. Additionally, besides being used for localization, the techniques underlying the SASSE system can also potentially be utilized for several similar 6-DOF estimation tasks in robotics, such as object pose estimation for robot grasping and manipulation.