GOTLoc: General Outdoor Text-based Localization
Using Scene Graph Retrieval with OpenStreetMap

Existing methods leveraging text for localization include [9, 10, 11, 12]. These studies employ the KITTI360Pose dataset[9], and focus on localization by comparing the similarity between point cloud maps and textual descriptions. Each study differs slightly depending on the methodologies used for comparing text and point cloud maps. First, [9] utilized an bidirectional Long Short-Term Memory (LSTM) [23], to identify similar scenes. Building on this work, [10] introduced the Relation Enhanced Transformer (RET) network, which improved performance by employing self-attention and cross-attention mechanisms to compare text and point cloud maps. Subsequently, [11] leveraged the Cascaded Cross Attention Transformer (CCAT) proposed in CASSPR[24], achieving superior localization performance compared to the RET-based approach [10]. Furthermore, Shang et al.[12] utilized three Mamba-based structures—Point Clouds Mamba (PCM), Text-Attention Mamba (TAM), and Cascaded Cross-Attention Mamba (CCAM)—based on the Mamba architecture proposed in [25], to perform text-based localization. Their approach currently represents the state-of-the-art performance for text-based localization using the KITTI360Pose dataset. However, these methods rely on point cloud maps for localization, which poses challenges such as storage requirements and scalability to larger spaces, limiting their practical applicability in real-world robotic systems.

In contrast, Where am I? [13] employed 3D scene graphs [16], for the text-based localization method. The research assessed the model’s performance using indoor scene graph datasets, including 3DSSG [17] and ScanScribe [18]. In addition, word2vec [26] was applied to process node and edge labels, generating both text and scene graphs. These graphs were then embedded using a graph transformer network with message passing, as proposed by [27], and similarity scores were calculated through a Multi-Layer Perceptron (MLP) to identify the most similar scenes. By representing scene data as scene graphs, their method addresses the challenges of existing text-based localization techniques [9, 10, 11, 12], which rely on large-scale point cloud map data. However, the scope of Where am I? [13] is confined to indoor environments.
In this paper, we extend the scope of text-based localization utilizing scene graph retrieval to outdoor environments, enabling it to operate in more diverse settings. To achieve this, we incorporate OSM, the graph Transformer network, and scene graph embedding data to perform an initial extraction of comparison candidates. As a result, the proposed method features compact scene data storage, fast processing speed, and high accuracy, establishing its significance as a real-time, high-performance city-scale outdoor localization solution.

First, the input data, consisting of text and OSM, is converted into scene graphs. The scene graph generation process is depicted in Fig. 3.

	$$\displaystyle G=\{N,\;E\},$$		(1)
	$$\displaystyle N=\{n\},\;E=\{e\},$$		(2)

where $G$ refers to a scene graph. $n$ and $e$ denote the nodes and edges that constitute the scene graph $G$, respectively. At this point, the nodes and edges correspond to the labels and relationships shown in Fig. 3. Furthermore, the center positions of the nodes are used solely for the calculation of relationships and do not directly define the nodes themselves. $N$ and $E$ represent the sets of $n$ and $e$, respectively.
For the text input, the source and target labels, along with the spatial relation between these labels, are parsed and represented as nodes and edges in the graph, respectively. For the OSM data, elements such as nodes, ways, and relations within a predefined distance from a reference point are extracted.

	$$\displaystyle T_{l},T_{r}=\phi(T),$$		(3)
	$$\displaystyle G^{T}=g^{T}(T_{l},T_{r}),$$		(4)

where $T$ represents the text description that depicts the scene. $\phi$ is a function used to extract labels and spatial relations from the text description. $T_{l}$ and $T_{r}$ represent the sets of extracted labels and spatial relations, respectively. $G^{T}$ refers to the scene graph generated from the text. Additionally, $g^{T}$ denotes the function that generates $G^{T}$ using two textual components.
Positional relationships between nodes are calculated, and if the distance between two nodes is below a predefined threshold, an edge is created between them. The positional differences between nodes in global coordinates are represented as vectors, and these vectors are used to determine the relationship represented by the edges. This process ultimately generates the OSM scene graph. Additionally, under the assumption that the ego’s heading angle is known in advance, we represent the edge relations of both the text and the OSM scene graphs in the East-North-Up (ENU) coordinate system using four directional components: North, South, East, and West. This ensures that the edge relations of the scene graphs generated from the two different data sources, text and OSM, are expressed within the same coordinate system, enabling direct graph-to-graph comparisons. The scene graph generation process can be formally represented as follows:

	$$\displaystyle\Delta p=p_{j}-p_{i},$$		(5)
	$$\displaystyle r^{M}_{i,j}=\begin{cases}North,&\text{if}\;\|\Delta p\|_{x}<\|\Delta p\|_{y},(\Delta p)_{y}>0\\ South,&\text{else if}\;\|\Delta p\|_{x}<\|\Delta p\|_{y},(\Delta p)_{y}<0\\ East,&\text{else if}\;\|\Delta p\|_{x}>\|\Delta p\|_{y},(\Delta p)_{x}>0\\ West,&\text{else if}\;\|\Delta p\|_{x}>\|\Delta p\|_{y},(\Delta p)_{x}<0\end{cases},$$		(6)

where $p$ represents the position of an object in the global coordinate system, and $\Delta p$ is the vector calculated as the positional difference between two objects. This vector is used to compute the spatial relation $r^{M}_{i,j}$ as in Eq. (6). $\|\cdot\|_{x,y}$ denotes the size of elements associated with $x$ or $y$ within the vector.

	$$\displaystyle G^{M}=g^{M}(M),\quad^{\forall}M\in\mathcal{M},$$		(7)
	$$\displaystyle\mathcal{G}^{M}=\{G^{M}\},$$		(8)

where $M$ is the submap cropped from the OSM based on a predefined distance. $\mathcal{M}$ represents the set of $M$, corresponding to the entirety of the OSM. $G^{M}$ denotes to the scene graph generated from the OSM. $g^{M}$ indicates the function that generates $G^{M}$ using the map data. $\mathcal{G}^{M}$ refers the set of $G^{M}$, constituting the scene graph database for the entire OSM.

To efficiently compare similarities between scene graphs stored in the database, converted from OSM into scene graphs, we first extract a set of candidate graphs that are expected to have high similarity. For this purpose, we utilize the graph embedding module for text and OSM scene graphs introduced in Sec. III-C. Using this module, we compute the embedding data for OSM scene graphs and store them in a vectorDB.

	$$\displaystyle E^{T}=\varepsilon(G^{T}),$$		(9)
	$$\displaystyle E^{M}_{i}=\varepsilon(G^{M}_{i}),\quad^{\forall}i\in\mathcal{I},$$		(10)

where $\varepsilon$ denotes a function that generates a graph embedding from either a text graph or a scene graph as input. $E$ refers to the graph embedding produced by $\varepsilon$. $\mathcal{I}$ represents the set of all scene ids stored in the database.
Then, we identify the embedding data most similar to the query text scene graph’s embedding data. The similarity between embedding vectors is calculated using cosine similarity.

$$\displaystyle S_{i}=\sigma(E^{T},E^{M}_{i})=\frac{E^{T}\cdot E^{M}_{i}}{\|E^{T}\|\cdot\|E^{M}_{i}\|},$$

(11)

where $\sigma$ refers to a function that calculates the similarity between two scene graph embeddings. $S$ corresponds to the similarity value produced as a result of $\sigma$. $\|\cdot\|$ is the size of the vector.
Subsequently, we extract the OSM scene ids with high similarities.

$$\displaystyle\mathbf{I}_{n}=\operatorname*{\arg\operatorname{top}}(S_{i},n),$$

(12)

where $\operatorname*{\arg\operatorname{top}}(\cdot,\cdot)$ corresponds to the argtop-k function, which extracts the indices of elements with the largest values. Among the function’s arguments, the first represents the reference value used for comparison in the argtop-k operation, while the second specifies the number of indices to be extracted as a result. Additionally, $n$ denotes the number of graph candidates to be extracted, which is applied as the second argument of the argtop-k function, as shown in Eq. (12). Finally, $\mathbf{I}_{n}$ represents the set of scene ids selected as the output of the argtop-k function.
Using the scene ids with high similarities, the corresponding candidate map scene graphs are extracted from the map scene graphs stored in the vectorDB.

$$\displaystyle\mathcal{C}=\{G^{M}_{i}\}=\psi(G^{T},\mathcal{G}^{M}),\quad^{\forall}i\in\mathbf{I}_{n},$$

(13)

where $\mathcal{C}$ is the set composed of map scene graphs $G^{M}_{i}$ that exhibit high similarity with the text scene graph $G^{T}$. $\psi$ represents the function used to extract $\mathcal{C}$.

As illustrated in Fig. 4, we employ a joint embedding framework, leveraging a graph transformer network, to generate embeddings for scene graphs, referring to [13]. Based on the model, the similarity between these graph embeddings is calculated, and the scene with the highest similarity is determined as the one corresponding to the current query text description. For the graph transformer network, we configure the network in the form of a joint embedding model comprising these graphGPS layers.

	$$\displaystyle\bar{E}^{T},\bar{E}^{M}_{i}=\bar{\varepsilon}(G^{T},G^{M}_{i}),\quad^{\forall}G^{M}_{i}\in\mathcal{C},$$		(14)
	$$\displaystyle\bar{S}_{i}=\bar{\sigma}(\bar{E}^{T},\bar{E}^{M}_{i}),$$		(15)

where $\bar{\varepsilon}$ denotes the joint embedding model that transforms a text graph and a scene graph. $\bar{E}$ represents the joint embedding of the text graph and scene graph generated as the output of $\bar{\varepsilon}$. $\bar{S}$ is the cosine similarity between two joint embedding data. $\bar{\sigma}$ indicates the function that calculates $\bar{S}$.
Finally, the scene id is predicted by applying the argtop-k operation to the cosine similarity scores. This process is formalized as follows:

$$\displaystyle I_{k}=\operatorname*{\arg\operatorname{top}}(\bar{S}_{i},k),\quad I_{k}\subset\mathbf{I}_{n},$$

(16)

where $k$ represents the number of scene ids selected as the result of the scene retrieval process and is applied as the second argument of the argtop-k function, as shown in Eq. (16). $I_{k}$ denotes the set of predicted scene ids that serve as the output of the scene retrieval process.
The constructed scene retrieval network is trained using a loss function composed of two components. First, the matching probability loss is computed based on the matching probability predicted by an MLP for two scene graph embeddings. Second, the cosine similarity loss is defined as the sum of the cosine similarity values directly calculated between the two embedding vectors. The joint embedding network is trained using this combined loss.

	$$\displaystyle\mathcal{L}_{mat}=MLP\left(\bar{E}^{T}\|\bar{E}^{M}_{i}\right),$$		(17)
	$$\displaystyle\mathcal{L}_{sim}=\bar{S}_{i},$$		(18)
	$$\displaystyle\mathcal{L}=\mathcal{L}_{mat}+\mathcal{L}_{sim},$$		(19)

where $MLP$ refers to the MLP component within the scene graph retrieval network architecture. $\mathcal{L}$ denotes the loss function of the scene graph retrieval network. $\mathcal{L}_{mat}$ and $\mathcal{L}_{sim}$ are the two components of $\mathcal{L}$, representing the matching probability loss and cosine similarity loss, respectively. $(\,\cdot\,\|\,\cdot\,)$ indicates the concatenation of two vectors.

In this paper, to evaluate the performance of the proposed GOTLoc, we adopted existing text-based localization methods, including Text2Pos[9], RET[10], Text2Loc[11], MambaPlace[12], and Where am I?[13], as baselines. Among these, Text2Pos, RET, Text2Loc, and MambaPlace were validated using the KITTI360Pose dataset. For a comparative analysis with these baselines, as shown in Table II, GOTLoc converted the segmented point cloud maps from the KITTI360Pose dataset into scene graphs. Additionally, the GPS coordinates corresponding to the poses in the KITTI360Pose dataset were utilized to generate submaps from OSM, which were then converted into scene graphs to serve as map data. To evaluate the performance of the proposed algorithm, we used Retrieval Recall as the evaluation metric. This metric calculates the proportion of true positive scenes correctly matched among all tested text queries. Specifically, as formalized in Eq. (16), the final predicted scene was selected by identifying the top $k$ candidates with the highest similarity and determining whether the true positive scene was included among these candidates. In this paper, $k$ was set to three different values—1, 3, and 5—by referencing prior text-based localization studies [9, 10, 11, 12]. The algorithm’s performance was then evaluated based on these values of $k$. Moreover, to validate performance through the ablation study and city-scale case, we evaluated performance by comparing the number of text-to-scene graph pairs processed per second, the time required to retrieve the entire scene graph for a given query scene graph, and the file size of the scene data as the evaluation metrics.

For the experiments conducted in our work, several Python packages were utilized. Specifically, OSMnx [28] was employed for processing OSM data, while GeoPandas [29] was used to convert GPS data into the UTM coordinate system. Additionally, Shapely [30] was utilized to handle geometric information from data loaded through OSMnx. Furthermore, NetworkX [31] was adopted for the processing and visualization of graph data. Furthermore, following prior studies[32, 33], the Milvus[19] vector database was employed as the vectorDB for storing the map scene graphs. The hardware configuration for this paper consisted of an Intel Xeon Gold 6140 2.30 GHz CPU and a 12 GB NVIDIA TITAN Xp GPU. The hardware specifications are comparable to those of commercially available edge computing devices, suggesting that the experimental results can be applied to real-world robotic scenarios.

The research questions we aim to address in this paper are as follows:
Q1. Can localization performance remain comparable even when the environment is represented with simplified data structures such as scene graphs, instead of precise data like point clouds? Q2. Does the scene graph generated from OSM achieve comparable overall algorithm performance to the scene graph generated from segmented point cloud maps? Q3. Does the proposed transformer network-based approach outperform the rule-based scene graph retrieval method, in terms of performance or provide advantages in speed? Q4. Compared to a brute-force retrieval method that evaluates all scenes, how much does the pre-selection of similar scene candidates improve speed, and does it maintain comparable performance? Q5. When scene data is converted from point clouds to scene graphs, how much storage efficiency is gained? Is it feasible for application in real-world robots? Q6. When applied to city-scale data, do accuracy, speed, and data storage requirements produce results that are practical for real-world robotic applications?

The data examples used in the experiments are illustrated in Fig. 5. These examples include text descriptions and GPS coordinates serving as input data for GOTLoc, the corresponding OSM data retrieved based on these inputs, and the resulting text and map scene graphs generated from this data. To further enhance comprehension, street view images[34] of the respective areas are also included. It should be noted that the segmentations shown in Fig. 5(b) and  5(c) were utilized solely for visualization purposes to facilitate understanding. Through the use of these data, the experiments aim to address the research questions outlined earlier in Sec. IV-C. The results of these validations are as follows:
Q1. Scene graph-based accuracy: The performance of methods leveraging scene graphs is shown in Table II. As described in Sec. IV-A, localization performance was evaluated by converting map data from the KITTI360Pose dataset into scene graphs. In the KITTI360Pose dataset, the direction was computed based on the relative positional differences between the observer and the object. However, in this paper, we did not include the observer as a node in the scene graph, rendering the direction information between the observer and the object unsuitable for use as edges in the scene graph. Therefore, we calculated the direction by applying the positional data of objects to Eq. (6) and utilized it as edges in the scene graph for this experiment. The results indicate that the performance shows minimal difference compared to using semantically segmented point cloud maps. This suggests that the scene graph-based map data used in GOTLoc contains sufficient information to be effectively utilized for localization.