diff --git a/.gitattributes b/.gitattributes index a268372f7700d3775a5659256d6b6334273b9589..21c384cc667ac84cb07bed0bcd2781009f108a01 100644 --- a/.gitattributes +++ b/.gitattributes @@ -6606,3 +6606,46 @@ qNFAT4oBgHgl3EQfex2-/content/2301.08578v1.pdf filter=lfs diff=lfs merge=lfs -tex H9FKT4oBgHgl3EQfdS4O/content/2301.11819v1.pdf filter=lfs diff=lfs merge=lfs -text X9AyT4oBgHgl3EQfvflc/content/2301.00631v1.pdf filter=lfs diff=lfs merge=lfs -text _dAzT4oBgHgl3EQfvf3k/content/2301.01709v1.pdf filter=lfs diff=lfs merge=lfs -text +ZdFRT4oBgHgl3EQfPzc_/content/2301.13518v1.pdf filter=lfs diff=lfs merge=lfs -text +lNE4T4oBgHgl3EQfTwzv/content/2301.05011v1.pdf filter=lfs diff=lfs merge=lfs -text +RtAzT4oBgHgl3EQf0P7C/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +idE4T4oBgHgl3EQfSgzP/content/2301.05000v1.pdf filter=lfs diff=lfs merge=lfs -text +9tE1T4oBgHgl3EQfoARp/content/2301.03315v1.pdf filter=lfs diff=lfs merge=lfs -text +dtE1T4oBgHgl3EQfLgMI/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +HtE1T4oBgHgl3EQfXwQA/content/2301.03129v1.pdf filter=lfs diff=lfs merge=lfs -text +4NE3T4oBgHgl3EQfogr8/content/2301.04635v1.pdf filter=lfs diff=lfs merge=lfs -text +ztFAT4oBgHgl3EQfBhzw/content/2301.08405v1.pdf filter=lfs diff=lfs merge=lfs -text +_tAyT4oBgHgl3EQfdveI/content/2301.00308v1.pdf filter=lfs diff=lfs merge=lfs -text +jNA0T4oBgHgl3EQfIv8h/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +bdFAT4oBgHgl3EQf5B6R/content/2301.08731v1.pdf filter=lfs diff=lfs merge=lfs -text +edE4T4oBgHgl3EQfQwxW/content/2301.04984v1.pdf filter=lfs diff=lfs merge=lfs -text +_dAzT4oBgHgl3EQfvf3k/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +lNE4T4oBgHgl3EQfTwzv/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +X9AyT4oBgHgl3EQfvflc/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +s9AzT4oBgHgl3EQfrv3p/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +0NFKT4oBgHgl3EQfNi2Q/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +xNAzT4oBgHgl3EQfdvyx/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +pNFPT4oBgHgl3EQfLjS4/content/2301.13023v1.pdf filter=lfs diff=lfs merge=lfs -text +gNFMT4oBgHgl3EQf2jEq/content/2301.12444v1.pdf filter=lfs diff=lfs merge=lfs -text +r9E1T4oBgHgl3EQfjAT1/content/2301.03259v1.pdf filter=lfs diff=lfs merge=lfs -text +edE4T4oBgHgl3EQfQwxW/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +59E1T4oBgHgl3EQfBQIH/content/2301.02848v1.pdf filter=lfs diff=lfs merge=lfs -text +0NFKT4oBgHgl3EQfNi2Q/content/2301.11755v1.pdf filter=lfs diff=lfs merge=lfs -text +_tAyT4oBgHgl3EQfdveI/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +ZdFRT4oBgHgl3EQfPzc_/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +ctFIT4oBgHgl3EQfnitG/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +6tE1T4oBgHgl3EQfBgIF/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +jNAyT4oBgHgl3EQfX_d5/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +pNFPT4oBgHgl3EQfLjS4/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +ctFIT4oBgHgl3EQfnitG/content/2301.11314v1.pdf filter=lfs diff=lfs merge=lfs -text +qNFQT4oBgHgl3EQfszbV/content/2301.13389v1.pdf filter=lfs diff=lfs merge=lfs -text +n9FPT4oBgHgl3EQfKTRi/content/2301.13018v1.pdf filter=lfs diff=lfs merge=lfs -text +ldE1T4oBgHgl3EQfNwO7/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +OtE1T4oBgHgl3EQfaASJ/content/2301.03157v1.pdf filter=lfs diff=lfs merge=lfs -text +ztFAT4oBgHgl3EQfBhzw/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +ddAzT4oBgHgl3EQf3f4p/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text +pNAyT4oBgHgl3EQfZPcw/content/2301.00218v1.pdf filter=lfs diff=lfs merge=lfs -text +bdA0T4oBgHgl3EQfGf9T/content/2301.02047v1.pdf filter=lfs diff=lfs merge=lfs -text +y9FAT4oBgHgl3EQfBBzs/content/2301.08402v1.pdf filter=lfs diff=lfs merge=lfs -text +yNFKT4oBgHgl3EQfLi3P/content/2301.11747v1.pdf filter=lfs diff=lfs merge=lfs -text +pNAyT4oBgHgl3EQfZPcw/vector_store/index.faiss filter=lfs diff=lfs merge=lfs -text diff --git a/0NFKT4oBgHgl3EQfNi2Q/content/2301.11755v1.pdf b/0NFKT4oBgHgl3EQfNi2Q/content/2301.11755v1.pdf new file mode 100644 index 0000000000000000000000000000000000000000..d2641a71f9ba019a0e747226107bb37b01a7233c --- /dev/null +++ b/0NFKT4oBgHgl3EQfNi2Q/content/2301.11755v1.pdf @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:04a38b5bad601459d534980f8e8607e56284cee87d4ca2858017ab62405abd16 +size 1773750 diff --git a/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.faiss b/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.faiss new file mode 100644 index 0000000000000000000000000000000000000000..e88603efea3c8f0c3049b566f80fc0c8cbd1ca56 --- /dev/null +++ b/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.faiss @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:51344577a7b8e4677b9deb77ff814b250958328f07025345afaae90ea6bda2cf +size 4718637 diff --git a/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.pkl b/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.pkl new file mode 100644 index 0000000000000000000000000000000000000000..c49e69a12427d0254543caf9e25c6f5a6946ba93 --- /dev/null +++ b/0NFKT4oBgHgl3EQfNi2Q/vector_store/index.pkl @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:f47fef613b87af855f0d496df0adef21fe0f7bb24e23d2c1069218b849b2ac37 +size 171549 diff --git a/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/2301.04620v1.pdf.txt b/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/2301.04620v1.pdf.txt new file mode 100644 index 0000000000000000000000000000000000000000..790421beae1a544f2b4fd7c05100f4bbc86a7371 --- /dev/null +++ b/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/2301.04620v1.pdf.txt @@ -0,0 +1,1998 @@ +arXiv:2301.04620v1 [eess.SY] 11 Jan 2023 +AdaptSLAM: Edge-Assisted Adaptive SLAM with +Resource Constraints via Uncertainty Minimization +Ying Chen∗, Hazer Inaltekin†, Maria Gorlatova∗ +∗Duke University, Durham, NC, †Macquarie University, North Ryde, NSW, Australia +∗{ying.chen151, maria.gorlatova}@duke.edu, †hazer.inaltekin@mq.edu.au +Abstract—Edge computing is increasingly proposed as a solu- +tion for reducing resource consumption of mobile devices running +simultaneous localization and mapping (SLAM) algorithms, with +most edge-assisted SLAM systems assuming the communication +resources between the mobile device and the edge server to be +unlimited, or relying on heuristics to choose the information to +be transmitted to the edge. This paper presents AdaptSLAM, an +edge-assisted visual (V) and visual-inertial (VI) SLAM system +that adapts to the available communication and computation re- +sources, based on a theoretically grounded method we developed +to select the subset of keyframes (the representative frames) for +constructing the best local and global maps in the mobile device +and the edge server under resource constraints. We implemented +AdaptSLAM to work with the state-of-the-art open-source V- +and VI-SLAM ORB-SLAM3 framework, and demonstrated that, +under constrained network bandwidth, AdaptSLAM reduces the +tracking error by 62% compared to the best baseline method. +Index Terms—Simultaneous localization and mapping, edge +computing, uncertainty quantification and minimization +I. INTRODUCTION +Simultaneous localization and mapping (SLAM), the pro- +cess of simultaneously constructing a map of the environ- +ment and tracking the mobile device’s pose within it, is an +essential capability for a wide range of applications, such +as autonomous driving and robotic navigation [1]. In partic- +ular, visual (V) and visual-inertial (VI) SLAM, which use +cameras either alone or in combination with inertial sensors, +have demonstrated remarkable progress over the last three +decades [2], and have become an indispensable component +of emerging mobile applications such as drone-based surveil- +lance [3], [4] and markerless augmented reality [5]–[8]. +Due to the high computational demands placed by the V- +and VI-SLAM on mobile devices [9]–[12], offloading parts of +the workload to edge servers has recently emerged as a promis- +ing solution for lessening the loads on the mobile devices and +improving the overall performance [9]–[18]. However, such +approach experiences performance degradation under resource +limitations and fluctuations. The existing edge-assisted SLAM +solutions either assume wireless network resources to be +sufficient for unrestricted offloading, or rely on heuristics in +making offloading decisions. By contrast, in this paper we +develop an edge computing-assisted SLAM framework, which +we call AdaptSLAM, that intelligently adapts to both commu- +nication and computation resources to maintain high SLAM +performance. Similar to prior work [11]–[17], AdaptSLAM +runs a real-time tracking module and maintains a local map +on the mobile device, while offloading non-time-critical and +computationally expensive processes (global map optimization +and loop closing) to the edge server. However, unlike prior +designs, AdaptSLAM uses a theoretically grounded method +to build the local and global maps of limited size, and +minimize the uncertainty of the maps, laying the foundation +for the optimal adaptive offloading of SLAM tasks under the +communication and computation constraints. +First, we develop an uncertainty quantification model for +the local and global maps in edge-assisted V-SLAM and VI- +SLAM. Specifically, since these maps are built from the infor- +mation contained in the keyframes (i.e., the most representative +frames) [19]–[21], the developed model characterizes how the +keyframes and the connections between them contribute to +the uncertainty. To the best of our knowledge, this is the first +uncertainty quantification model for V-SLAM and VI-SLAM in +edge-assisted architectures. +Next, we apply the developed uncertainty quantification +model to efficiently select subsets of keyframes to build local +and global maps under the constraints of limited computation +and communication resources. The local and global map +construction is formulated as NP-hard cardinality-constrained +combinatorial optimization problems [22]. We demonstrate +that the map construction problems are ‘close to’ submodular +problems under some conditions, propose a low-complexity +greedy-based algorithm to obtain near-optimal solutions, and +present a computation reuse method to speed up map construc- +tion. We implement AdaptSLAM in conjunction with the state- +of-the-art open-source V- and VI-SLAM ORB-SLAM3 [20] +framework, and evaluate the implementation with both sim- +ulated and real-world communication and computation con- +ditions. Under constrained bandwidth, AdaptSLAM reduces +the tracking error by 62% compared with the best baseline +method. +To summarize, the main contributions of this paper are: (i) +the first uncertainty quantification model of maps in V- and +VI-SLAM under the edge-assisted architecture, (ii) an analyt- +ically grounded algorithm for efficiently selecting subsets of +keyframes to build local and global maps under computation +and communication resource budgets, and (iii) a compre- +hensive evaluation of AdaptSLAM on two configurations of +mobile devices. We open-source AdaptSLAM via GitHub.1 +The rest of this paper is organized as follows. §II reviews +the related work, §III provides the preliminaries, §IV and +1https://github.com/i3tyc/AdaptSLAM + +§V introduce the AdaptSLAM system architecture and model, +§VI presents the problem formulation, and §VII presents the +problem solutions. We present the evaluation in §VIII and +conclude the paper in §IX. +II. RELATED WORK +V- and VI-SLAM. Due to the affordability of cameras and +the richness of information provided by them, V-SLAM has +been widely studied in the past three decades [2]. It can be +classified into direct approaches (LSD-SLAM [23], DSO [24]), +which operate directly on pixel intensity values, and feature- +based approaches (PTAM [25], ORB-SLAM2 [19], Pair- +Navi [26]), which extract salient regions in each camera +frame. We focus on feature-based approaches since direct +approaches require high computing power for real-time per- +formance [2]. To provide robustness (to textureless areas, +motion blur, illumination changes), there is a growing trend +of employing VI-SLAM, that assists the cameras with an +inertial measurement unit (IMU) [20], [21], [27]; VI-SLAM +has become the de-facto standard SLAM method for modern +augmented reality platforms [5], [6]. In VI-SLAM, visual +information and IMU data can be loosely [27] or tightly [20], +[21] coupled. We implement AdaptSLAM based on ORB- +SLAM3 [20], a state-of-the-art open-source V- and VI-SLAM +system which tightly integrates visual and IMU information. +Edge-assisted SLAM. Recent studies [4], [9], [11], [13]– +[18], [28]–[30] have focused on offloading parts of SLAM +workloads from mobile devices to edge (or cloud) servers +to reduce mobile device resource consumption. A standard +approach is to offload computationally expensive tasks (global +map optimization, loop closing), while exploiting onboard +computation for running the tasks critical to the mobile +device’s autonomy (tracking, local map optimization) [11], +[13]–[18]. Most edge-assisted SLAM frameworks assume +wireless network resources to be sufficient for unconstrained +offloading [4], [13]–[16], [29]; some use heuristics to choose +the information to be offloaded under communication con- +straints [9], [11], [17], [18], [28], [30]. Some frameworks only +keep the newest keyframes in the local map to combat the +constrained computation resources on mobile devices [14], +[16]. Complementing this work, we propose a theoretical +framework to characterize how keyframes contribute to the +SLAM performance, laying the foundation for the adaptive +offloading of SLAM tasks under the communication and +computation constraints. +Uncertainty quantification and minimization. Recent +work [31]–[33] has focused on quantifying and minimizing +the pose estimate uncertainty in V-SLAM. Since the pose +estimate accuracy is difficult to obtain due to the lack of +ground-truth poses of mobile devices, the uncertainty can +guide the decision-making in SLAM systems. In [31], [32], +it is used for measurement selection (selecting measurements +between keyframes [31] and selecting extracted features of +keyframes [32]); in [33], it is used for anchor selection (se- +lecting keyframes to make their poses have ‘zero uncertainty’). +Complementing this work, we quantify the pose estimate +uncertainty of both V- and VI-SLAM under the edge-assisted +architecture. After the uncertainty quantification, we study +the problem of selecting a subset of keyframes to minimize +the uncertainty. This problem is largely overlooked in the +literature, but is of great importance for tackling computation +and communication constraints in edge-assisted SLAM. +III. PRELIMINARIES +A. Graph Preliminaries +A directed multigraph is defined by the tuple of sets G = +(V, E, C), where V = {v1, · · · , v|V|} is the set of nodes, E is +the set of edges, and C is the set of edge categories. Let e = +((vi, vj), c) ∈ E denote the edge, where the nodes vi, vj ∈ V +are the head and tail of e, and c ∈ C is the category of e. +We let we be the weight of edge e. We allow multiple edges +from vi to vj to exist, and denote the set of edges from vi to +vj by Ei,j. Note that the edges in Ei,j are differentiated from +each other by their category labels. The total edge weight from +nodes vi to vj is given by wi,j = +� +e∈Ei,j +we, which is the sum +of all edge weights from vi to vj. +The weighted Laplacian matrix L of graph G is a |V| × |V| +matrix where the i, j-th element Li,j is given by: +Li,j = +� −wi,j, +i ̸= j +� +e∈Ei +we, +i = j +, +where Ei ⊆ E is the set of all edges whose head is node vi. +The reduced Laplacian matrix ˜L is obtained by removing an +arbitrary node (i.e., removing the row and column associated +to the node) from L. +B. Set Function +We define a set function f for a finite set V as a mapping +f : 2V → R that assigns a value f (S) to each subset S ⊆ V . +Submodularity. A set function f is submodular if f (L) + +f (S) ⩾ f (L ∪ S) + f (L ∩ S) for all L, S ⊆ V . +Submodularity ratio. The submodularity ratio of a set +function f with respect to a parameter s is +γ = +min +L⊆V,S⊆V,|S|⩽s,x∈V \(S∪L) +f (L ∪ {x}) − f (L) +f (L ∪ S ∪ {x}) − f (L ∪ S). +(1) +where we define 0/0 := 1. +The cardinality-fixed maximization problem is +max +S⊆V,|S|=s f (S) . +(2) +The keyframe selection optimization is closely related to +the cardinality-fixed maximization problem introduced above, +which is an NP-hard problem [34]. However, for submodular +set functions, there is an efficient greedy approach that will +come close to the optimum value for (2), with a provable +optimality gap. This result is formally stated in Theorem 1. +Theorem 1. +[34], [35] Given a non-negative and monoton- +ically increasing set function f with a submodularity ratio γ, +let S# be the solution produced by the greedy algorithm + +(Algorithm 1) and S⋆ be the solution of (2). Then, f +� +S#� +⩾ +(1 − exp(−γ)) f (S⋆) . +C. SLAM Preliminaries +The components of SLAM systems include [2], [20], [21]: +Tracking. The tracking module detects 2D feature points +(e.g., by extracting SIFT, SURF, or ORB descriptors) in the +current frame. Each feature point corresponds to a 3D map +point (e.g., a distinguishable landmark) in the environment. +The tracking module uses these feature points to find corre- +spondences with a previous reference frame. It also processes +the IMU measurements. Based on the correspondences in +feature points and the IMU measurements, it calculates the +relative pose change between the selected reference frame and +the current frame. The module also determines if this frame +should be a keyframe based on a set of criteria such as the +similarity to the previous keyframes [20]. +Local and global mapping. It finds correspondences (of +feature points) between the new keyframe and the other +keyframes in the map. It then performs map optimizations, +i.e., estimates the keyframe poses given the common feature +points between the keyframes and the IMU measurements. +Map optimizations are computationally expensive. In edge- +assisted SLAM, global mapping runs on the server [11], [13]– +[17]. +Loop closing. By comparing the new keyframe to all +previous keyframes, the module checks if the new keyframe is +revisiting a place. If so (i.e., if a loop is detected), it establishes +connections between the keyframe and all related previous +ones, and then performs global map optimizations. Loop +closing is computationally expensive and can be offloaded to +the edge server in the edge-assisted SLAM [11], [13]–[17]. +IV. ADAPTSLAM SYSTEM ARCHITECTURE +The design of AdaptSLAM is shown in Fig. 1. The mobile +device, equipped with a camera and an IMU, can communicate +with the edge server bidirectionally. The mobile device and the +edge server cooperatively run SLAM algorithms to estimate +the mobile device’s pose and a map of the environment. +AdaptSLAM optimizes the SLAM performance under compu- +tation resource limits of the mobile device and communication +resource limits between the mobile device and the edge server. +We split the modules between the mobile device and the +edge server similar to [11], [13]–[18]. The mobile device +offloads loop closing and global map optimization modules +to the edge server, while running real-time tracking and local +mapping onboard. Unlike existing edge-assisted SLAM sys- +tems [11], [13]–[18], AdaptSLAM aims to optimally construct +the local and global maps under the computation and commu- +nication resource constraints. The design of AdaptSLAM is +Algorithm 1 Greedy algorithm to solve (2) +1: S# ← ∅; +2: while ( +��S#�� < s) do +3: +x⋆ ← arg max +x +f(S#∪{x})−f(S#). S# ← S#∪{x⋆}. +Mobile Device +Edge Server +Tracking +Local Map +Optimization +Global Map +Construction +Global Map +Optimization +Loop Closing +IMU +Image +Local Map +Construction +Candidate +Keyframes +Selected +Keyframes +Detected +Loop +Local +Map +Global +Map +Fig. 1: Overview of the AdaptSLAM system architecture. +mainly focused on two added modules, local map construction +and global map construction highlighted in purple in Fig. 1. +In local map construction, due to the computation resource +limits, the mobile device selects a subset of keyframes from +candidate keyframes to build a local map. In global map +construction, to adapt to the constrained wireless connection +for uplink transmission, the mobile device also selects a subset +of keyframes to be transmitted to the edge server to build a +global map. The AdaptSLAM optimally selects the keyframes +to build local and global maps, minimizing the pose estimate +uncertainty under the resource constraints. +Similar to [11], the selected keyframes are transmitted from +the mobile device to the server, and the map after the global +map optimization is transmitted from the server to the mobile +device. For the uplink transmission, instead of the whole +keyframe, the 2D feature points extracted from the keyframes +are sent. For the downlink communication, the poses of the +keyframes obtained by the global map optimization, and the +feature points of the keyframes are transmitted. +V. ADAPTSLAM SYSTEM MODEL +A. The Pose Graph and the Map +We divide time into slots of equal size of ∆t. We introduce +the pose graph and the map at time slot t that lasts for ∆t +seconds. For clarity of notation, we will omit the time index +below. +Definition 1 (Pose graph). For a given index set K = +{1, . . ., |K|} +(indexing +camera +poses +and +representing +keyframes), the pose graph is defined as the undirected multi- +graph G = (K, E, C), where K is the node set, E is the edge +set, and C = {IMU, vis} is the category set. Here, IMU stands +for the IMU edges, and vis stands for the covisibility edges. +Given a pose graph G = (K, E, C), there is a camera pose +Pn = (x, y, z, wx, wy, wz) for all n ∈ K, where the first +three entries are the 3-D positions and the last three ones are +the Euler angles (yaw, pitch and roll) representing the camera +orientation. Edges in E are represented as e = ((n, m), c) for +n, m ∈ K and c ∈ C. Two keyframes in K are connected +by a covisibility edge if there are 3D map points observed +in both keyframes. Two consecutive keyframes are connected +by an IMU edge if there are accelerometer and gyroscope +readings from one keyframe to another. There may exist both +a covisibility edge and an IMU edge between two keyframes. +For each e = ((n, m), c) ∈ E, we observe relative noisy +pose measurements between n and m, which is written as +∆e = Pm − Pn + xe, where xe is the measurement noise + +on edge e. The map optimization problem is to find the +maximum likelihood estimates {˜Pn}n∈K for the actual camera +poses {Pn}n∈K. For Gaussian distributed edge noise, the map +optimization problem is +min +{˜Pn}n∈K +� +e∈E +(˜xe)⊤Ie˜xe, +(3) +where ˜xe = ∆e − ˜Pm + ˜Pn and Ie is the information matrix +(i.e., inverse covariance matrix) of the measurement error on +e [36]. (˜xe)⊤ Ie˜xe is the Mahalanobis norm [20], [21] of the +estimated measurement noise for e with respect to Ie. +Below, we assume that the measurement noise xe is Gaus- +sian distributed with isotropic covariance (as in [31], [37], +[38]). We assume that the information matrix Ie can be +characterized by a weight assigned to e [37], [39]. Specifically, +Ie = weI, where we ⩾ 1 is the weight for e and I is the +matrix that is constant for all measurements. We note that the +relative measurements between keyframes n and m introduce +the same information for them. We assume all weights we to +be independent from each other for edges between different +pairs of keyframes as in [20], [21], [39], [40]. +The map optimization problem in (3) is solved by standard +methods such as Levenberg-Marquardt algorithm implemented +in g2o [41] and Ceres solvers [42] as in [20], [21]. +Definition 2 (Anchor). We say that a node is the anchor of +the pose graph if the pose of the node is known. +The map (local or global) consists of the pose graph (in +Definition 1) and map points in the environment. In this paper, +we will use the terms map and pose graph interchangeably. +Without loss of generality, we will also assume that the global +(or local) map is anchored on the first node, as in [37], [39]. +This assumption is made because SLAM can only estimate +the relative pose change based on the covisibility and inertial +measurements, while the absolute pose estimate in the global +coordinate system cannot be provided. +B. The Local Map +Local map construction. The candidate keyframes are se- +lected from camera frames according to the selection strategy +in ORB-SLAM3 [20], and these candidate keyframes form +the set K. Due to the constrained computation resources, +the mobile device selects a fixed keyframe set Kfixed and a +local keyframe set Kloc from the candidate keyframes, where +|Kfixed| ⩽ lf and |Kloc| ⩽ lloc. The fixed keyframe set +Kfixed ⊆ Kg,user is selected from the global map Kg,user +that was last transmitted from the edge server. The poses +of keyframes in Kfixed act as fixed priors in the local map +optimization. This is because poses of keyframes in Kg,user +are already optimized in the global map optimization and +hence have low uncertainty. The poses of keyframes in the +local keyframe set Kloc ⊆ K \ Kg,user will be optimized +according to the map optimization problem introduced above. +The edges between keyframes in Kloc form the set Eloc, and +the edges whose one node belongs to Kloc and another node +belongs to Kfixed form the set El,f. +Local map optimization. After selecting Kloc in the local +map construction, the local map optimization is to optimize +the estimated poses +� +˜Pn +� +n∈Kloc +to minimize the sum of +Mahalanobis norms +� +e∈Eloc∪El,f +(˜xe)⊤Ie˜xe. Note that in the +local pose graph optimization, the keyframes in Kfixed are +included in the optimization with their poses fixed. The local +map optimization to solve (3) is +min +{˜Pn}n∈Kloc +� +e∈Eloc∪El,f +(˜xe)⊤Ie˜xe. +(4) +C. The Global Map +Global map construction. Due to the limited bandwidth +between the mobile device and the edge server, only a subset +of candidate keyframes are offloaded to the edge server to +build a global map. The selection of keyframes to be offloaded +will be optimized to minimize the pose estimation uncertainty +of the global map when considering the underlying wireless +network constraints. +The edge server maintains the global map, denoted as +Kg,edge, holding all keyframes uploaded by the mobile device. +The edges between keyframes in the global map Kg,edge +constitute the set Eglob. Note that Kg,edge may be different +from Kg,user, because the global map is large and it takes +time to transmit the most up-to-date global map from the edge +server to the mobile device. +Global map optimization. After selecting Kg,edge in the +global map construction, the edge server performs the global +map optimization to estimate poses +˜Pn in Kg,edge and +minimize the sum of Mahalanobis norms +� +e∈Eglob +(˜xe)⊤Ie˜xe. +Specifically, the edge solves (3) when E = Eglob and K = +Kg,edge, i.e., the global map optimization is to solve +min +{˜Pn}n∈Kg,edge +� +e∈Eglob +(˜xe)⊤Ie˜xe. +(5) +VI. PROBLEM FORMULATION +AdaptSLAM aims to efficiently select keyframes to con- +struct optimal local and global maps, i.e., we select keyframes +in Kloc and Kfixed for the local map and Kg,edge for the +global map. From §IV, after constructing the optimal local and +global maps, the map optimization can be performed using the +standard algorithms [41], [42]. We construct optimal local and +global maps by minimizing the uncertainty of the keyframes’ +estimated poses. Hence, we represent and quantify the uncer- +tainty in §VI-A, and formulate the uncertainty minimization +problems in §VI-B. +A. Uncertainty Quantification +Let pn += +˜Pn − Pn denote the pose estimate error +of keyframe n. The estimated measurement noise can be +rewritten as �xe = pn − pm + xe = pn,m + xe, where +pn,m += +pn − pm. We stack all pn, n +∈ +K and get +a pose estimate error vector w += +� +p⊤ +1 , p⊤ +2 , · · · , p⊤ +|K| +� +. +We rewrite the objective function of map optimization + +in (3) as +� +e∈E +(˜xe)⊤Ie˜xe += +� +e=((n,m),c)∈E +p⊤ +n,mIepn,m + +2 +� +e=((n,m),c)∈E +p⊤ +n,mIexe + � +e∈E +x⊤ +e Iexe. If we can rewrite +the quadratic term +� +e=((n,m),c)∈E +p⊤ +n,mIepn,m in the format of +wIww⊤, where Iw is called the information matrix of the +pose graph, the uncertainty of the pose graph is quantified by +− log det (Iw) according to the D-optimality [31]–[33].2 +We denote the pose estimate error vectors for the global +and local maps as wg += +� +p⊤ +u1, · · · , p⊤ +u|Kg,edge| +� +and +wl = +� +p⊤ +r1, · · · , p⊤ +r|Kloc| +� +, where u1, · · · , u|Kg,edge| are the +keyframes in Kg,edge, and r1, · · · , r|Kloc| are the keyframes +in Kloc. The first pose in the global and local pose graph is +known (pu1 = 0, pr1 = 0). We rewrite the quadratic terms of +the objective functions of global and local map optimizations +in +(5) +and +(4) +as +� +e=((n,m),c)∈Eglob +p⊤ +n,mIepn,m += +wgIglob (Kg,edge) w⊤ +g (or +� +e=((n,m),c)∈Eloc∪El,f +p⊤ +n,mIepn,m = +wlIloc (Kloc, Kfixed)w⊤ +l ), +where +Iglob (Kg,edge) +and +Iloc (Kloc, Kfixed) are called the information matrices of +the global and local maps and will be derived later (in +Definition 3 and Lemmas 1 and 2). +Definition 3 (Uncertainty). The uncertainty of the global (or +local) pose graph is defined as − log det +� +˜Iglob (Kg,edge) +� +(or − log det +� +˜Iloc (Kloc, Kfixed) +� +, where ˜Iglob (Kg,edge) and +˜Iloc (Kloc, Kfixed) are obtained by removing the first row and +first column in the information matrices Iglob (Kg,edge) and +Iloc (Kloc, Kfixed). +From Definition 3, the uncertainty quantification is based +on the global and local map optimizations introduced in §V-C +and §V-B. After quantifying the uncertainty, we will later (in +§VI-B) optimize the local and global map construction which +in turn minimizes the uncertainty of poses obtained from local +and global map optimizations. +Lemma 1 (Uncertainty of global pose graph). For the +global map optimization, the uncertainty is calculated as +− log det +� +˜Iglob (Kg,edge) +� +, where ˜Iglob (Kg,edge) = ˜Lglob⊗I +with ˜Lglob being the matrix obtained by deleting the first row +and column in the Laplacian matrix Lglob, and ⊗ being the +Kronecker product. The i, j-th element of Lglob is given by +[Lglob]i,j = + + + + + +− +� +e=((ui,uj),c)∈Eg,edge +we, +i ̸= j +� +e=((ui,q),c)∈Eg,edge,ui̸=q +we, +i = j +. +(6) +Proof. See Appendix A. Proof sketch: The proof follows from +the global map optimization formulation in §V-C and the +definition of ˜Iglob (Kg,edge). +2Common approaches to quantifying uncertainty in SLAM are to use real +scalar functions of the maximum likelihood estimator covariance matrix [43]. +Among them, D-optimality (determinant of the covariance matrix) [37], [39] +captures the uncertainty due to all the elements of a covariance matrix and +has well-known geometrical and information-theoretic interpretations [44]. +From Lemma 1, the uncertainty of the global pose graph +can be calculated based on the reduced Laplacian matrix +(˜Lglob). According to the relationship between the reduced +Laplacian matrix and the tree structure [45], the uncertainty is +inversely proportional to the logarithm of weighted number of +spanning trees in the global pose graph. Similar conclusions +are drawn for 2D pose graphs [31] and 3D pose graphs with +only covisibility edges [37], [39], where the device can move +in 2D plane and 3D space respectively. We extend the results +to VI-SLAM where the global pose graph is a multigraph with +the possibility of having both a covisibility edge and an IMU +edge between two keyframes. +Lemma 2 (Uncertainty of local pose graph). The uncertainty +is − log det +� +˜Iloc (Kloc, Kfixed) +� +for the local map, where +˜Iloc (Kloc, Kfixed) = ˜Lloc ⊗ I with ˜Lloc being the matrix +obtained by deleting the first row and the first column in Lloc. +The i, j-th element of Lloc (of size |Kloc| × |Kloc|) is given by +[Lloc]i,j = + + + + + +− +� +e=((ri,rj),c)∈Eloc +we, +i ̸= j +� +e=((ri,q),c)∈El,f∪Eloc,q̸=ri +we, i = j +. +(7) +Proof. See Appendix B. Proof sketch: Setting pn += 0, +n ∈ Kfixed (the fixed keyframes have poses with ‘zero +uncertainty’), the proof follows from the local pose graph +optimization formulation in §V-B and the definition of +˜Iloc (Kloc, Kfixed). +From Lemma 2, the uncertainty of the local map is propor- +tional to the uncertainty of the pose graph G anchoring on the +first node in Kloc and all nodes in Kfixed, where G’s node set is +Kfixed∪Kloc and edge set includes all measurements between +any two nodes in Kfixed ∪ Kloc. Note that keyframe poses +in Kfixed are optimized on the edge server and transmitted +to the mobile device, and they are considered as constants +in the local pose graph optimization. From the uncertainty’s +perspective, adding fixed keyframes in Kfixed is equivalent +to anchoring these keyframe poses (i.e., deleting rows and +columns corresponding to the anchored nodes in the Laplacian +matrix of graph G). In addition, from Lemma 2, although poses +are fixed, the anchored nodes still reduce the uncertainty of +the pose graph. Hence, apart from Kloc, we will select the +anchored keyframe set Kfixed to minimize the uncertainty. +B. Uncertainty Minimization Problems +We now formulate optimization problems whose objectives +are to minimize the uncertainty of the local and global +maps. For the local map optimization, under the computation +resource constraints, we solve Problem 1 for each keyframe k. +For the global map optimization, under the communication +resource constraints, we solve Problem 2 to adaptively offload +keyframes to the edge server. + +Problem 1 (Local map construction). +max +Kloc,Kfixed log det +� +�Iloc (Kloc ∪ {k} , Kfixed) +� +(8) +s.t. +|Kloc| ⩽ lloc, Kloc ⊆ K \ Kg,user +(9) +|Kfixed| ⩽ lf, Kfixed ⊆ Kg,user. +(10) +The objective of Problem 1 is equivalent to minimizing the +uncertainty of the local map. Constraint (9) means that the size +of Kloc is constrained to reduce the computational complexity +in the local map optimization, and that the keyframes to +be optimized in the local map are selected from keyframes +that are not in Kg,user. Constraint (10) means that the size +of Kfixed is constrained, and that the fixed keyframes are +selected from Kg,user that were previously optimized on and +transmitted from the edge server. +Problem 2 (Global map construction). +max +K′⊆K\Kg,edge log det +� +�Iglob (Kg,edge ∪ K′) +� +(11) +s.t. d |K′| ⩽ D. +(12) +The objective of Problem 2 is equivalent to minimizing the +uncertainty of the global map. K \ Kg,edge is set of the +keyframes that have not been offloaded to the server, and +we select a subset of keyframes, K′, from K \ Kg,edge. +The constraint (12) guarantees that the keyframes cannot be +offloaded from the device to the server at a higher bitrate than +the available channel capacity, where D is the channel capacity +constraint representing the maximum number of bits that can +be transmitted in a given transmission window. We assume that +the data size d of each keyframe is the same, which is based on +the observation that the data size is relatively consistent across +keyframes in popular public SLAM datasets [46], [47]. +VII. LOCAL AND GLOBAL MAP CONSTRUCTION +We analyze the properties of approximate submodularity +in map construction problems, and propose low-complexity +algorithms to efficiently construct local and global maps. +A. Local Map Construction +The keyframes in the local map include those in two disjoint +sets Kloc and Kfixed. To efficiently solve Problem 1, we +decompose it into two problems aiming at minimizing the +uncertainty: Problem 3 that selects keyframes in Kloc and +Problem 4 that selects keyframes in Kfixed. We obtain the +optimal local keyframe set K⋆ +loc in Problem 3. Based on K⋆ +loc, +we then obtain the optimal fixed keyframe set K⋆ +fixed in +Problem 4. We will compare the solutions to Problems 3 and 4 +with the optimal solution to Problem 1 in §VIII to show that +the performance loss induced by the decomposition is small. +Problem 3. +K⋆ +loc = arg max +Kloc log det +� +˜Iloc(Kloc∪ {k}, ∅) +� +s.t. (9). +Problem 4. +K⋆ +fixed = arg max +Kfixed log det +� +˜Iloc(K⋆ +loc∪ {k}, Kfixed) +� +s.t. (10). +1) The Selection of Local Keyframe Set Kloc: We first +solve Problem 3. It is a nonsubmodular optimization problem +with constraints, which are NP-hard and generally difficult +to be solved with an approximation ratio [22]. Hence, we +decompose Problem 3 into subproblems (Problems 5 and 6) +that are equivalent to the original Problem 3 and can be +approximately solved with a low-complexity algorithm. +In problem 5, assume that we already select a keyframe +subset Kbase from K \ Kg,user (with the size lb ≜ |Kbase| ⩽ +lloc), and we aim to further select a keyframe set Kadd +to be added to Kbase to minimize the local map uncer- +tainty. Rewriting the objective as Unc (Kadd ∪ Kbase ∪ {k}) ≜ +− log det +� +�Iloc (Kadd ∪ Kbase ∪ {k}, ∅) +� +, the problem is to +obtain the optimal Kadd (denoted as OPTadd(Kbase)) given +Kbase: +Problem 5. +OPTadd (Kbase) = arg max +Kadd −Unc (Kadd ∪ Kbase ∪ {k}) +s.t. +|Kadd| ⩽ lloc − lb. +After getting the solutions (i.e., OPTadd (Kbase)) to Prob- +lem 5 for all possible Kbase of size lb, we obtain the optimal +Kbase (denoted as K⋆ +base) in Problem 6. +Problem 6. +K⋆ +base = arg max +Kbase −Unc (OPTadd(Kbase) ∪ Kbase ∪ {k}) +s.t. +|Kbase| = lb. +Lemma 3. Given lb, the solution to Problems 5 and 6, i.e., +K⋆ +base and OPTadd (K⋆ +base), will give us the solution K⋆ +loc to +Problem 3. Specifically, K⋆ +loc = K⋆ +base ∪ OPTadd (K⋆ +base). +Proof. The proof is straightforward and hence omitted. +We can obtain K⋆ +loc in Problem 3 by solving Problems 5 +and 6. We will show that the objective function of Problem 5 is +‘close to’ a submodular function when the size of the keyframe +set Kbase is large. In this case, Problem 5 can be efficiently +solved using a greedy algorithm with an approximation ratio. +When |Kbase| is small, we need to compare the objective +function for different combinations of Kbase and Kadd. +Lemma 4. When +wmax +|Kbase|wmin < 1, the submodularity ratio γ +of the objective function in Problem 5 is lower bounded by +γ ⩾ 1 + 1 +ϑ log +� +1 − +4|Kadd|2w2 +max +|Kbase| wmin − wmax +� +, +(13) +where +ϑ += +min +m∈Kadd +� +n∈Kbase +log wn,m, +wmax += +max +n,m∈Kbase∪Kadd wn,m, and wmin = +min +n,m∈Kbase∪Kadd wn,m. γ +is close to 1 when |Kbase| is significantly larger than |Kadd|. + +Algorithm 2 Selecting local keyframe set Kloc in the local +map (top-h greedy-based algorithm) +1: Θ ← ∅; +2: while ( |Λ| ⩽ lloc) do +3: +if |Λ| ⩽ lthr then h ← H else h ← 1; +4: +Select +the +top-h +highest-scoring +combinations +of +Λ, Λ ∈ Θ and n, n ∈ K \ Kg,user that minimize +Unc (Λ ∪ {n, k}). Unc (Λ ∪ {n, k}) is calculated using +the computation reuse algorithm in Algorithm 2; +5: +Update Θ as the set of h highest-scoring combinations +of Λ and n. Each element of Θ is a set (i.e., Λ ∪ {n}) +corresponding to one combination; +6: K⋆ +loc ← arg min +Λ∈Θ Unc(Λ ∪ {k}). +Proof. See Appendix C. Proof sketch: Following from the +definition of γ in (1), we first prove that the denomina- +tor in (1), denoted as log det(Mden), is lower bounded +by ϑ. Denoting the numerator in (1) as log det(Mnum), +we +show +that +log det(Mnum) +⩾ +log det(Mden) + +log +� +1 − +4|Kadd|2w2 +max +|Kbase|wmin−wmax +� +, by proving that the absolute val- +ues of all elements in Mnum are bounded. +From Lemma 4, the objective function in Problem 5 is +‘close to’ a submodular function when the size of the exist- +ing keyframe set (i.e., |Kbase|) is much larger than |Kadd|. +Hence, we can use the greedy algorithm to approximately +solve Problem 5. According to Theorem 1, the solution +obtained by the greedy algorithm for Problem 5, denoted +by OPT# +add (Kbase), has an approximation guarantee that +OPT# +add (Kbase) ⩾ (1 − exp(−γ)) OPTadd (Kbase). +According to the analysis of the properties of Problems 5 +and 6, we now solve Problem 3 to select the local keyframe set +Kloc using Algorithm 2 (top-h greedy-based algorithm). Θ is +the set of possible keyframe sets that minimize the local map +uncertainty, and we only maintain h keyframe sets to save +the computation resources. Λ, Λ ∈ Θ, denotes the element +in Θ and represents one possible keyframe set. When the +size of Λ is smaller than a threshold lthr (|Λ| ⩽ lthr), we +select the top-H (H > 1) highest-scoring combinations of +Λ and n, n ∈ K \ Kg,user, that minimize Unc (Λ ∪ {k, n}). +When |Λ| gets larger, we only select the highest-scoring +combination. The reasons are as follows. Λ can be seen as the +existing keyframe set Kbase. According to Lemma 4, when +the size of the existing keyframe set (which is |Λ| here) is +small, there is no guarantee that Unc (Kadd ∪ Kbase ∪ {k}) is +close to a submodular function (i.e., the submodularity ratio +is much smaller than 1). Hence, we need to try different +combinations of Λ and n to search for the combination that +minimizes the uncertainty after each iteration. As |Λ| grows, +the submodularity ratio is close to 1, and a greedy algorithm +can achieve η approximation (η = 1 − exp(−γ), γ → 1). +In this case, we apply the greedy algorithm and only keep +the combination that achieves the minimal uncertainty at each +step. +Algorithm 3 Computation reuse algorithm +1: Input: det(A), A−1; +2: B ← A−1. Calculate BiB⊤ +i , i = 1, · · · , |Λ|; +3: Calculate (A′)−1 using (15). Calculate det (A′) using +(16). Calculate det(˜I (Λ ∪ {n, k})) using (14). +2) Computation Reuse Algorithm: We use the computation +reuse algorithm (Algorithm 3) to speed up Algorithm 2. We +observe that for different n, n ∈ K \ Kg,user, only a limited +number (3|Λ|+1) of elements in the matrix ˜I (Λ ∪ {n, k}) are +different. Calculating the log-determinant function of a (|Λ|+ +1)×(|Λ|+1) matrix ˜I (Λ ∪ {n, k}) has a high computational +complexity (of O(|Λ|+1)3) [48]. Hence, instead of computing +the objective function for each n from scratch, we reuse parts +of computation results for different n. +Letting A ≜ ˜I (Λ ∪ {k}) denote the information matrix of +the local map in the |Λ|-th iteration (of Algorithm 2), the infor- +mation matrix in the (|Λ|+1)-th iteration is ˜I (Λ ∪ {n, k}) = +� +A + diag (a) +a⊤ +a +d +� +, where a = (a1, a2, · · · , a|Λ|) with +ai = wλi,n, λi is the i-th element of Λ, and d = wk,n+ +|Λ| +� +i=1 +ai. +We aim to calculate det(˜I (Λ ∪ {n, k})) using the calcula- +tion of det(A) and A−1 from the previous iteration. Letting +A′ ≜ A + diag(a), det(˜I (Λ ∪ {n, k})) is calculated by +det(˜I (Λ ∪ {n, k})) = (d − a(A′)−1a⊤) det(A′). +(14) +Next we efficiently calculate (A′)−1 and det(A′) to get +det(˜I (Λ ∪ {n, k})). We can rewrite A′ as A′ += A + +|Λ| +� +i=1 +β⊤ +i βi where βi = + +0, · · · , √ai +���� +i−th +, · · · , 0 + +. According to +Sherman–Morrison formula [49], (A′)−1 is given by +(A′)−1 ≈ +B +���� +Reuse +− +|Λ| +� +i=1 +ai +1 + aiBi,i +BiB⊤ +i +� �� � +Reuse +, +(15) +where B = A−1, Bi,i is the i, i-th element of B, and Bi is +the i-th column vector of B. Using (15), B and BiB⊤ +i can be +computed only once to be used for different n, n ∈ K\Kg,user, +which greatly reduces the computational cost. According to the +rank-1 update of determinant [49], det(A′) can be written as +det (A′) = det (A) (1 + a1B1,1) {1(|Λ| = 1) + 1(|Λ| > 1) +× +|Λ| +� +i=2 + +1 + ai + +B − +i−1 +� +j=1 +ajBjBT +j +1 + ajBj,j + + +i,i + + + + + . +(16) +� +B − +i−1 +� +j=1 +ajBjBT +j +1+ajBj,j +� +is already calculated in (15), which re- +duces the computational complexity. Substituting (15) and (16) +into (14), we get the final results of det(˜I (Λ ∪ {n, k})). +The computation complexity of different algorithms. +If we select keyframes in Kloc using a brute-force algo- +rithm based on exhaustive enumeration of combinations of + +keyframes in Kloc, the complexity is O +�� ρ +lloc +� +l3 +loc +� +, where +ρ = |K \ Kg,user| is the number of keyframes that have not +been offloaded to the edge server. Without computation reuse, +the computation complexity of the proposed top-h greedy- +based algorithm is O(Hρl4 +loc). With computation reuse, it is +reduced to O(Hl4 +loc) + O(Hρl3 +loc). Since we only keep lloc +keyframes in Kloc of the local map and a small H in Algo- +rithm 2 to save computation resources, i.e., ρ ≫ lloc > H, +the proposed greedy-based algorithm with computation reuse +significantly reduces the computational complexity. +3) The Selection of Fixed Keyframe Set Kfixed: After +selecting the local keyframe set Kloc by solving Problem 3, +we solve Problem 4 to select the fixed keyframe set. +Lemma 5. Problem 4 is non-negative, monotone and submod- +ular with a cardinality-fixed constraint. +Proof sketch. It is straightforward to prove the non-negativity +and monotonicity. For the submodularity, we can prove that +det(�Iloc(K⋆ +loc∪{k},L)) det(�Iloc(K⋆ +loc∪{k},S)) +det(�Iloc(K⋆ +loc∪{k},L∪S)) det(�Iloc(K⋆ +loc∪{k},∅)) ⩾ 1, using the +property that det(M) ⩾ det(N) holds for positive semidefi- +nite matrices M, N when M−N is positive semidefinite. +Lemma 5 indicates that the problem can be approximately +solved with greedy methods in Algorithm 1 [34]. For each +iteration, the algorithm selects one keyframe from Kg,user to +be added to the fixed keyframe set Kfixed. The approximation +ratio η = 1−exp(−1) guarantees that worst-case performance +of a greedy algorithm cannot be far from optimal. +B. Global Map Construction +We use a low-complexity algorithm to solve Problem 2 to +construct the global map. The objective function of Problem 2 +can be rewritten as −Unc (Kg,edge ∪ K′), which has the same +structure as that of Problem 3. Problems 2 and 3 both add +keyframes to the existing keyframe sets to construct a pose +graph and optimize the keyframe poses in the pose graph. +Hence, Algorithms 2 and 3 can be used to solve Problem 2. +In Algorithm 2, lloc is replaced by +D +d , and K \ Kg,user is +replaced by K \ Kg,edge. Calculating the uncertainty of a +large global map is computationally intensive, and hence the +proposed low-complexity algorithm is essential to reducing the +computational load on the mobile device. +VIII. EVALUATION +We implement AdaptSLAM on the open-source ORB- +SLAM3 [20] framework which typically outperforms older +SLAM methods [25], [26], with both V- and VI- configura- +tions. The edge server modules are run on a Dell XPS 8930 +desktop with Intel (R) Core (TM) i7-9700K CPU@3.6GHz +and NVIDIA GTX 1080 GPU under Ubuntu 18.04LTS. In +§VIII-A, the mobile device modules are run on the same +desktop under simulated computation and network constraints. +In §VIII-B, the mobile device modules are implemented on a +laptop (with an AMD Ryzen 7 4800H CPU and an NVIDIA +GTX 1660 Ti GPU), using a virtual machine with 4-core CPUs +and 8GB of RAM. The weight we, e = ((n, m), c) is set as the +number of common map features visible in keyframes n and +m for covisibility edges, similar to [20], [50], and the IMU +edge weight is set as a large value (i.e., 500) as the existence +of IMU measurements greatly reduces the tracking error. We +empirically set H = 5 and lthr = 30 in Algorithm 2 to ensure +low complexity and good performance at the same time. +Metric. We use root mean square (RMS) absolute trajectory +error (ATE) as the SLAM performance metric which is com- +monly used in the literature [20], [51]. ATE is the absolute +distance between the estimated and ground truth trajectories. +Baseline methods. We compare AdaptSLAM with 5 base- +lines. Random selects the keyframe randomly. DropOldest +drops the oldest keyframes when the number of keyframes +is constrained. ORBBuf, proposed in [28], chooses the +keyframes that maximize the minimal edge weight between +the adjacent selected keyframes. BruteForce examines all the +combinations of keyframes to search for the optimal one that +minimizes the uncertainty (in Problems 1 and 2). BruteForce +can achieve better SLAM performance than AdaptSLAM +but is shown to have exponential computation complexity +in §VII-A. In the original ORB-SLAM3, the local map +includes all covisibility keyframes, and the global map in- +cludes all keyframes. The original ORB-SLAM3 also achieves +better SLAM performance and consumes more computation +resources than AdaptSLAM as the numbers of keyframes in +both local and global maps are large. +Datasets. We evaluate AdaptSLAM on public SLAM +datasets containing V and VI sequences, including TUM [47] +and EuRoC [46]. The difficulty of a SLAM sequence depends +on the extent of device mobility and scene illumination. We +use EuRoC sequences V101 (easy), V102 (medium), and V103 +(difficult), and difficult TUM VI room1 and room6 sequences. +We report the results over 10 trials for each sequence. +A. Simulated Computation and Network Constraints +First, we limit the number of keyframes in the local map +under computation constraints, and all keyframes are used +to build the global map without communication constraints. +Second, we maintain local maps as in the default settings +of ORB-SLAM3, and limit the number of keyframes in the +global map under constrained communications, where D in +Problem 2 is set according to the available bandwidth. +Local map construction. We demonstrate the RMS ATE of +different keyframe selection methods, for different V-SLAM +(Fig. 2a) and VI-SLAM (Fig. 2b) sequences. The size of +the local map is limited to 10 keyframes and 9 anchors +in V-SLAM sequences, and 25 keyframes and 10 anchors +in VI-SLAM sequences (to ensure successful tracking while +keeping a small local map). AdaptSLAM reduces the RMS +ATE compared with Random, DropOldest, and ORBBuf by +more than 70%, 62%, and 42%, averaged over all sequences. +The performance of AdaptSLAM is close to BruteForce, which +demonstrates that our greedy-based algorithms yield near- +optimal solutions, with substantially reduced computational +complexity. Moreover, the performance of AdaptSLAM is close +to the original ORB-SLAM3 (less than 0.05 m RMS ATE + +V101 +V102 +V103 +room1 +room6 +Sequence +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +RMS ATE (m) +Random +DropOldest +ORBBuf +BruteForce +ORB-SLAM3 +AdaptSLAM +(a) V-SLAM +V101 +V102 +V103 +room1 +room6 +Sequence +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +RMS ATE (m) +Random +DropOldest +ORBBuf +BruteForce +ORB-SLAM3 +AdaptSLAM +(b) VI-SLAM +Fig. 2: RMS ATE for 6 keyframe selection methods in the local map construction for 5 +sequences in EuRoC and TUM. +Random DropOldest ORBBuf AdaptSLAM +Method +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +RMS ATE (m) +lloc = 10 +lloc = 20 +lloc = 30 +Fig. 3: RMS ATE for different sizes +of local keyframe set (for EuRoC +V102). +V101 +V102 +V103 +room1 +room6 +Sequence +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +0.7 +RMS ATE (m) +Random +DropOldest +ORBBuf +BruteForce +ORB-SLAM3 +AdaptSLAM +(a) V-SLAM +V101 +V102 +V103 +room1 +room6 +Sequence +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +RMS ATE (m) +Random +DropOldest +ORBBuf +BruteForce +ORB-SLAM3 +AdaptSLAM +(b) VI-SLAM +Fig. 4: RMS ATE for 6 keyframe selection methods in the global map construction for +5 sequences in EuRoC and TUM. +Random DropOldest ORBBuf AdaptSLAM +Method +0.0 +0.2 +0.4 +0.6 +0.8 +1.0 +RMS ATE (m) +40Mbps +80Mbps +w/o bandwidth + limitation +Fig. +5: +RMS +ATE +for different +available bandwidth for offloading +keyframes (for EuRoC V102). +difference for all sequences) even though the size of the local +map is reduced by more than 75%. +The influence of the number lloc of keyframes in the local +map on the RMS ATE for different methods is shown in +Fig. 3. We present the results for EuRoC V102 (of medium +difficulty), which are representative. When lloc is reduced +from 30 to 10, AdaptSLAM increases the RMS ATE by only +6.7%, to 0.09 m, as compared to 0.37, 0.16, and 0.12 m +for, correspondingly, Random, DropOldest, and ORBBuf. This +indicates that AdaptSLAM achieves low tracking error under +stringent computation resource constraints. +Global map construction. First, we examine the case +where only half of all keyframes are offloaded to build a +global map, for V-SLAM (Fig. 4a) and VI-SLAM (Fig. 4b) +sequences. AdaptSLAM reduces the RMS ATE compared with +the closest baseline ORBBuf by 27% and 46% on average for +V- and VI-SLAM, and has small performance loss compared +with the original ORB-SLAM3, despite reducing the number +of keyframes by half. +Next, in Fig. 5, we examine four methods whose perfor- +mance is impacted by the available bandwidth, under different +levels of communication constraints. Without bandwidth lim- +itations, all methods have the same performance as the global +map holds all keyframes. When the bandwidth is limited, +Random and DropOldest have the worst performance as they +ignore the relations of keyframes in the pose graph. The +ORBBuf performs better, but the tracking error is increased +by 4.0× and 9.8× when the bandwidth is limited to 80 +and 40 Mbps. AdaptSLAM achieves the best performance, +reducing the RMS ATE compared to ORBBuf by 62% and 78% +when network bandwidth is 80 and 40 Mbps, correspondingly. +This highlights the superiority of AdaptSLAM in achieving +high tracking accuracy under communication constraints. +foot1 +foot3 +foot5 +Network trace +0.0 +0.1 +0.2 +0.3 +0.4 +0.5 +0.6 +0.7 +RMS ATE (m) +Random +DropOldest +ORBBuf +AdaptSLAM +Fig. 6: RMS ATE for dif- +ference network traces. +Method +Latency (ms) +Random +133.0±86.3 +DropOldest +139.9±53.7 +ORBBuf +149.3±75.6 +BruteForce +863.4±123.5 +ORB-SLAM3 +556.4±113.7 +AdaptSLAM +162.8±68.9 +TABLE I: The latency for local +map construction and optimization. +B. Real-World Computation and Network Constraints +Following the approach of splitting modules between the +edge server and the mobile device [11], we split the modules +as shown in Fig. 1. The server and the device are connected +via a network cable to minimize other factors. To ensure +reproducibility, we replay the network traces collected from a +4G network [52]. Focusing on mobile devices carried by users, +we choose network traces (foot1, foot3, and foot5) collected +by pedestrians. We set D in Problem 2 according to the traces. +We examine the RMS ATE under the network traces in +Fig. 6 for the EuRoC V102 sequence. The results for only +four methods are presented because the overall time taken for +running the SLAM modules onboard is high for BruteForce +and the original SLAM. AdaptSLAM reduces the RMS ATE by +65%, 61%, and 35% (averaged over all traces) compared with +Random, DropOldest, and ORBBuf. AdaptSLAM achieves +high tracking accuracy under real-world network traces. +Table I shows the computation latency of mobile devices +for all six methods. We compare the latency for running +local map construction and optimization, which is the main +source of latency for modules running onboard [11]. Compared + +with AdaptSLAM, the original ORB-SLAM3 takes 3.7× as +much time for optimizing the local map as all covisibility +keyframes are included in the local map without keyframe +selection. Without the edge-assisted architecture, the original +ORB-SLAM3 also runs global mapping and loop closing +onboard which have even higher latency [11]. BruteForce takes +5.3× as much time for examining all the combinations of +keyframes to minimize the local map uncertainty. The latency +for constructing and optimizing local maps using AdaptSLAM +is close to that using Random and DropOldest (<12.3% +difference). Low latency for local mapping shows that edge- +assisted SLAM is appealing, as local mapping is the biggest +source of delay for modules executing onboard after offloading +the intensive tasks (loop closing and global mapping). +IX. CONCLUSION +We present AdaptSLAM, an edge-assisted SLAM that effi- +ciently select subsets of keyframes to build local and global +maps, under constrained communication and computation re- +sources. AdaptSLAM quantifies the pose estimate uncertainty +of V- and VI-SLAM under the edge-assisted architecture, and +minimizes the uncertainty by low-complexity algorithms based +on the approximate submodularity properties and computation +reuse. AdaptSLAM is demonstrated to reduce the size of the +local keyframe set by 75% compared with the original ORB- +SLAM3 with a small performance loss. +ACKNOWLEDGMENTS +This work was supported in part by NSF grants CSR- +1903136, CNS-1908051, and CNS-2112562, NSF CAREER +Award IIS-2046072, by an IBM Faculty Award, and by the +Australian Research Council under Grant DP200101627. +REFERENCES +[1] D. M. Rosen, K. J. Doherty, A. Ter´an Espinoza, and J. J. Leonard, +“Advances in inference and representation for simultaneous localization +and mapping,” Annu. Rev. Control Robot. Auton. Syst., vol. 4, pp. 215– +242, 2021. +[2] C. Cadena, L. Carlone, H. Carrillo, Y. Latif, D. Scaramuzza, J. Neira, +I. Reid, and J. J. Leonard, “Past, present, and future of simultaneous +localization and mapping: Toward the robust-perception age,” IEEE +Trans. Robot., vol. 32, no. 6, pp. 1309–1332, 2016. +[3] C. Forster, S. Lynen, L. Kneip, and D. Scaramuzza, “Collabora- +tive monocular SLAM with multiple micro aerial vehicles,” in Proc. +IEEE/RSJ IROS, 2013. +[4] R. Williams, B. Konev, and F. Coenen, “Scalable distributed collabora- +tive tracking and mapping with micro aerial vehicles,” in Proc. IEEE/RSJ +IROS, 2015. +[5] Google. (2022) ARCore. https://developers.google.com/ar. +[6] Apple. (2022) ARKit. https://developer.apple.com/augmented-reality/arkit/. +[7] T. Scargill, G. Premsankar, J. Chen, and M. Gorlatova, “Here to stay: A +quantitative comparison of virtual object stability in markerless mobile +AR,” in Proc. IEEE/ACM Workshop on Cyber-Physical-Human System +Design and Implementation, 2022. +[8] Y.-J. Yeh and H.-Y. Lin, “3D reconstruction and visual SLAM of indoor +scenes for augmented reality application,” in Proc. IEEE ICCA, 2018. +[9] J. Xu, H. Cao, D. Li, K. Huang, C. Qian, L. Shangguan, and Z. Yang, +“Edge assisted mobile semantic visual SLAM,” in Proc. IEEE INFO- +COM, 2020. +[10] H. Cao, J. Xu, D. Li, L. Shangguan, Y. Liu, and Z. Yang, “Edge assisted +mobile semantic visual SLAM,” IEEE Trans. Mob. Comput., vol. 1, +no. 1, pp. 1–15, 2022. +[11] A. J. Ben Ali, Z. S. Hashemifar, and K. Dantu, “Edge-SLAM: Edge- +assisted visual simultaneous localization and mapping,” in Proc. ACM +MobiSys, 2020. +[12] A. J. B. Ali, M. Kouroshli, S. Semenova, Z. S. Hashemifar, S. Y. Ko, and +K. Dantu, “Edge-SLAM: edge-assisted visual simultaneous localization +and mapping,” ACM Trans. Embed. Comput. Syst., vol. 22, no. 1, pp. +1–31, 2022. +[13] I. Deutsch, M. Liu, and R. Siegwart, “A framework for multi-robot pose +graph SLAM,” in Proc. IEEE RCAR, 2016. +[14] M. Karrer, P. Schmuck, and M. Chli, “CVI-SLAM—collaborative visual- +inertial SLAM,” IEEE Robot. Autom. Lett., vol. 3, no. 4, pp. 2762–2769, +2018. +[15] F. Li, S. Yang, X. Yi, and X. Yang, “CORB-SLAM: a collaborative +visual SLAM system for multiple robots,” in CollaborateCom. Springer, +2017. +[16] P. Schmuck and M. Chli, “CCM-SLAM: Robust and efficient centralized +collaborative monocular simultaneous localization and mapping for +robotic teams,” J. Field Robot., vol. 36, no. 4, pp. 763–781, 2019. +[17] K.-L. Wright, A. Sivakumar, P. Steenkiste, B. Yu, and F. Bai, “Cloud- +SLAM: Edge offloading of stateful vehicular applications,” in Proc. +IEEE/ACM SEC, 2020. +[18] J. Xu, H. Cao, Z. Yang, L. Shangguan, J. Zhang, X. He, and Y. Liu, +“SwarmMap: Scaling up real-time collaborative visual SLAM at the +edge,” in Proc. USENIX NSDI, 2022. +[19] R. Mur-Artal and J. D. Tard´os, “ORB-SLAM2: An open-source SLAM +system for monocular, stereo, and RGB-D cameras,” IEEE Trans. Robot., +vol. 33, no. 5, pp. 1255–1262, 2017. +[20] C. Campos, R. Elvira, J. J. G. Rodr´ıguez, J. M. Montiel, and J. D. +Tard´os, “ORB-SLAM3: An accurate open-source library for visual, +visual–inertial, and multimap SLAM,” IEEE Trans. Robot., 2021. +[21] T. Qin, P. Li, and S. Shen, “VINS-Mono: A robust and versatile +monocular visual-inertial state estimator,” IEEE Trans. Robot., vol. 34, +no. 4, pp. 1004–1020, 2018. +[22] A. A. Bian, J. M. Buhmann, A. Krause, and S. Tschiatschek, “Guar- +antees for greedy maximization of non-submodular functions with +applications,” in Proc. PMLR ICML, 2017. +[23] J. Engel, T. Sch¨ops, and D. Cremers, “LSD-SLAM: Large-scale direct +monocular SLAM,” in Proc. Springer ECCV, 2014. +[24] J. Engel, V. Koltun, and D. Cremers, “Direct sparse odometry,” IEEE +Trans. Pattern Anal. Mach. Intell., vol. 40, no. 3, pp. 611–625, 2017. +[25] G. Klein and D. Murray, “Parallel tracking and mapping for small AR +workspaces,” in Proc. IEEE ISMAR, 2007. +[26] E. Dong, J. Xu, C. Wu, Y. Liu, and Z. Yang, “Pair-Navi: Peer-to-peer +indoor navigation with mobile visual SLAM,” in Proc. IEEE INFOCOM, +2019. +[27] S. Weiss, M. W. Achtelik, S. Lynen, M. Chli, and R. Siegwart, “Real- +time onboard visual-inertial state estimation and self-calibration of +MAVs in unknown environments,” in Proc. IEEE ICRA, 2012. +[28] Y.-P. Wang, Z.-X. Zou, C. Wang, Y.-J. Dong, L. Qiao, and D. Manocha, +“ORBBuf: A robust buffering method for remote visual SLAM,” in Proc. +IEEE/RSJ IROS, 2021. +[29] L. Riazuelo, J. Civera, and J. M. Montiel, “C2TAM: A cloud framework +for cooperative tracking and mapping,” Robot. Auton. Syst., vol. 62, +no. 4, pp. 401–413, 2014. +[30] P. Huang, L. Zeng, X. Chen, K. Luo, Z. Zhou, and S. Yu, “Edge robotics: +Edge-computing-accelerated multi-robot simultaneous localization and +mapping,” IEEE Internet Things J., 2022. +[31] K. Khosoussi, M. Giamou, G. S. Sukhatme, S. Huang, G. Dissanayake, +and J. P. How, “Reliable graphs for SLAM,” Int. J. Robot. Res., vol. 38, +no. 2-3, pp. 260–298, 2019. +[32] L. Carlone and S. Karaman, “Attention and anticipation in fast visual- +inertial navigation,” IEEE Trans. Robot., vol. 35, no. 1, pp. 1–20, 2018. +[33] Y. Chen, L. Zhao, Y. Zhang, S. Huang, and G. Dissanayake, “Anchor +selection for SLAM based on graph topology and submodular optimiza- +tion,” IEEE Trans. Robot., 2021. +[34] G. L. Nemhauser, L. A. Wolsey, and M. L. Fisher, “An analysis of +approximations for maximizing submodular set functions—I,” Mathe- +matical programming, vol. 14, no. 1, pp. 265–294, 1978. +[35] A. Das and D. Kempe, “Approximate submodularity and its applications: +Subset selection, sparse approximation and dictionary selection,” J. +Mach. Learn. Res., vol. 19, no. 1, pp. 74–107, 2018. +[36] L. Carlone, G. C. Calafiore, C. Tommolillo, and F. Dellaert, “Planar +pose graph optimization: Duality, optimal solutions, and verification,” +IEEE Trans. Robot., vol. 32, no. 3, pp. 545–565, 2016. + +[37] J. A. Placed and J. A. Castellanos, “Fast autonomous robotic exploration +using the underlying graph structure,” in Proc. IEEE/RSJ IROS, 2021. +[38] K. Khosoussi, S. Huang, and G. Dissanayake, “Tree-connectivity: Eval- +uating the graphical structure of SLAM,” in Proc. IEEE ICRA, 2016. +[39] Y. Chen, S. Huang, L. Zhao, and G. Dissanayake, “Cram´er–Rao bounds +and optimal design metrics for pose-graph SLAM,” IEEE Trans. Robot., +vol. 37, no. 2, pp. 627–641, 2021. +[40] N. Boumal, A. Singer, P.-A. Absil, and V. D. Blondel, “Cram´er–Rao +bounds for synchronization of rotations,” Information and Inference: A +Journal of the IMA, vol. 3, no. 1, pp. 1–39, 2014. +[41] R. K¨ummerle, G. Grisetti, H. Strasdat, K. Konolige, and W. Burgard, +“g2o: A general framework for graph optimization,” in IEEE ICRA, +2011. +[42] S. +Agarwal, +K. +Mierle, +and +Others, +“Ceres +solver,” +http://ceres-solver.org. +[43] M. L. Rodr´ıguez-Ar´evalo, J. Neira, and J. A. Castellanos, “On the +importance of uncertainty representation in active SLAM,” IEEE Trans. +Robot., vol. 34, no. 3, pp. 829–834, 2018. +[44] F. Pukelsheim, Optimal design of experiments. +SIAM, 2006. +[45] K. Khosoussi, S. Huang, and G. Dissanayake, “Novel insights into the +impact of graph structure on SLAM,” in IEEE/RSJ IROS, 2014. +[46] M. Burri, J. Nikolic, P. Gohl, T. Schneider, J. Rehder, S. Omari, M. W. +Achtelik, and R. Siegwart, “The EuRoC micro aerial vehicle datasets,” +Int. J. Rob. Res., vol. 35, no. 10, pp. 1157–1163, 2016. +[47] D. Schubert, T. Goll, N. Demmel, V. Usenko, J. St¨uckler, and D. Cre- +mers, “The TUM VI benchmark for evaluating visual-inertial odometry,” +in Proc. IEEE/RSJ IROS, 2018. +[48] G. Strang, Linear algebra and its applications. Thomson, Brooks/Cole, +2006. +[49] G. H. Golub and C. F. Van Loan, Matrix computations. +JHU press, +2013. +[50] Y. Chen, L. Zhao, K. M. B. Lee, C. Yoo, S. Huang, and R. Fitch, +“Broadcast your weaknesses: Cooperative active pose-graph SLAM for +multiple robots,” IEEE Robot. Autom. Lett, vol. 5, no. 2, pp. 2200–2207, +2020. +[51] Z. Zhang and D. Scaramuzza, “A tutorial on quantitative trajectory +evaluation for visual (-inertial) odometry,” in Proc. IEEE/RSJ IROS, +2018. +[52] J. Van Der Hooft, S. Petrangeli, T. Wauters, R. Huysegems, P. R. Alface, +T. Bostoen, and F. De Turck, “HTTP/2-based adaptive streaming of +HEVC video over 4G/LTE networks,” IEEE Commun. Lett., vol. 20, +no. 11, pp. 2177–2180, 2016. +APPENDIX +A. Proof of Lemma 1 +The quadratic term of the objective function in (5) is +� +e=((n,m),c)∈Eglob +p⊤ +n,mIepn,m, where p⊤ +n,mIepn,m can be +rewritten as +p⊤ +n,mIepn,m +=we +� +p⊤ +n , p⊤ +m +� � +I6I +−I6I +−I6I +I6I +� +(pn, pm) +=wgΞew⊤ +g , +(17) +where the i, j-th block of Ξe, [Ξe]i,j, is derived as +[Ξe]i,j = + + + +−weI, +ui = n, uj = m +weI, +ui = uj = n +0, +otherwise +. +From the definition of Iglob (Kg,edge) and the global pose +graph optimization formulation in §V-C, we can obtain that +Iglob (Kg,edge) = +� +e∈Eg,edge +Ξe. Hence, Lglob is given by (6), +which concludes the proof. +B. Proof of Lemma 2 +As introduced in §V-B, the local pose graph optimization is +to solve +min +{ ˜Pn}n∈Kloc +� +e∈Eloc∪El,f +(xe)⊤Iexe. In optimizing poses +of keyframes in Kloc, the poses of keyframes in Kfixed are +fixed. Hence, the quadratic term of the objective function can +be rewritten as +� +e=((n,m),c)∈Eloc∪El,f +p⊤ +n,mIepn,m += +� +e=((n,m),c)∈Eloc +p⊤ +n,mIepn,m ++ +� +e=((n,m),c)∈El,f,n∈Kloc,m∈Kfixed +p⊤ +n Iepn ++ +� +e=((n,m),c)∈El,f,n∈Kfixed,m∈Kloc +� +−p⊤ +m +� +Ie (−pm) . +According to the above analysis, we can reformulate (4) as +min +{ ˜Pn}n∈Kloc +wlΛloc (Kloc, Kfixed) w⊤ +l , +where Λloc (Kloc, Kfixed) is the |Kloc| × |Kloc| block matrix +whose i, j-th block is +[Λloc (Kloc, Kfixed)]i,j = + + + + + + + + + + + + + + + + + +− +� +e=((ri,rj),c)∈Eloc +weI, +i ̸= j +� +� +e=((ri,q),c)∈El,f,q∈Kfixed +we + +� +e=((ri,q),c)∈Eloc,q∈Kloc,q̸=ri +we +� +I +, +i = j +. +According to the uncertainty definition in Definition 3, +the uncertainty of the local pose graph is calculated as +− log det +� +˜Iloc (Kloc, Kfixed) +� +, where ˜Iloc (Kloc, Kfixed) is +given by (7). +C. Proof of Lemma 4 +According to the definition of the submodularity ratio given +in (1), the submodularity ratio γ of the objective function in +Problem 5 can be calculated as (18), where (a) follows from +the definition of the submodularity ratio. The denominator of +(18), denoted as ς, is lower bounded by +ς = log +det +� +˜Iloc (Kbase ∪ L ∪ S ∪ {x, k} , ∅) +� +det +� +˜Iloc (Kbase ∪ L ∪ S ∪ {k}) , ∅ +� +⩾ +� +n∈Kbase∪L∪S +log wx,n +⩾ +min +m∈Kadd +� +n∈Kbase +log wn,m ≜ ϑ, +(20) +where the first inequality is due to the fact that the determinant +of the reduced weighted Laplacian matrix is equal to the tree- +connectivity of its corresponding graph [31]. + +γ +(a) += +min +L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L +−Unc (Kbase ∪ L ∪ {x}) + Unc (Kbase ∪ L) +−Unc (Kbase ∪ L ∪ S ∪ {x}) + Unc (Kbase ∪ L ∪ S) += +min +L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L +log +det(˜Iloc(Kbase∪L∪{x,k},∅)) +det(˜Iloc(Kbase∪L∪{k}),∅) +log +det(˜Iloc(Kbase∪L∪S∪{x,k},∅)) +det(˜Iloc(Kbase∪L∪S∪{k}),∅) +. +(18) +γ = 1 + +log +� +min +L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L +det(˜Iloc(Kbase∪L∪{x,k},∅)) det(˜Iloc(Kbase∪L∪S∪{k}),∅) +det(˜Iloc(Kbase∪L∪S∪{x,k},∅)) det(˜Iloc(Kbase∪L∪{k}),∅) +� +ς += 1 + +log + + + + + + + + +min +L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L det + + + + + + + + + + + +Q1+Q2+ + + +0z +I|S| +0 + + + + + + + +Q1+Q3+ + + 0z+|S| +1 + + + + +(Q1+Q2+Q3+Q4) + +Q1+ + + 0 +0 +0 +I|S|+1 + + + + + + + + + + + + + + + + + + + + +ς += 1 + +log + + + + +min +L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L det +(Q1)2+Q1Q2+Q1Q3+(Q2+Q3) + + 0 +0 +0 +I|S|+1 + ++Q2Q3 +(Q1)2+Q1Q2+Q1Q3+(Q2+Q3) + + 0 +0 +0 +I|S|+1 + ++Q4 + + + + +ς +(a) +⩾ 1 + 1 +ϑ log +� +1 − g1Q−1g⊤ +1 +� +. +(19) +Substituting (20) into (18), γ can be further calculated +by (19), where Ii and 0i are the i × i identity matrix and +zero matrix, and Q = Q1 + Q2 + Q3 + Q4. Q1, Q2, Q3 and +Q4 are defined as follows. We express Kbase ∪ L ∪ S ∪ {x, k} +as {si}i={1,··· ,z+|S|+2} where z = |Kbase ∪L|, si ∈ Kbase ∪L +when i ⩽ z, si ∈ S when z < i ⩽ z + |S|, sz+|S|+1 = x, +and sz+|S|+2 = k. For each edge e, we define a vector qe, +and each element [qe]i = −[qe]j = we if vertexes si and +sj are the head or tail of e and zero otherwise. We then get +˜qe after removing the last element of qe. Q1, Q2, Q3 and +Q4 are defined as Q1 = +1 +2 +� +e=((si,sj),c),si,sj∈Kbase∪L +�qe�q⊤ +e +( 1 +2 is used because the edges from si to sj and from sj +to si are both included), Q2 = +� +e=((si,x),c),si∈Kbase∪L +�qe�q⊤ +e , +Q3 += +� +e=((si,sj),c),si∈Kbase∪L,sj∈S +�qe�q⊤ +e , +and +Q4 += +� +e=((x,sj),c),sj∈S +�qe�q⊤ +e . g1 is given by +g1 = + +0, · · · , 0 +� �� � +z ‘0′s +, −wx,s1, · · · , −wx,s|S| +|S| +� +i=1 +wx,si + + , +where wmax = +max +n,m∈Kbase∪Kadd wn,m, and wx,si ⩽ wmax +for si ∈ S. (a) in (19) is because for invertible positive +semidefinite matrices M, N, det(M) ⩾ det(N) holds when +M − N is positive semidefinite [48]. +We will prove that +��Q−1�� ⩽ +1 +|Kbase|wmin−wmax when +|Kbase| is significantly larger than |Kadd|, where ∥M∥ is the +l∞ norm of M (defined as the largest magnitude among each +element in M), and wmin = +min +n,m∈Kbase∪Kadd wn,m. Rewrite +Q as Q = DQ − EQ, where DQ is a diagonal matrix +with elements on the diagonal the same as those of Q, and +EQ = DQ − Q. Q−1 is calculated as +Q−1 = +� +Iz+|S|+1 − D−1 +Q EQ +�−1 +D−1 +Q += +� ∞ +� +i=0 +� +D−1 +Q EQ +�i +� +D−1 +Q . +D−1 +Q EQ has the properties that all elements in D−1 +Q EQ are +positive and smaller than +wmax +|Kbase|wmin , and all row vectors has +an l∞ norm smaller than 1. Hence, we have +���� +� +D−1 +Q EQ +�i���� ⩽ +wmax +|Kbase|wmin . + +Q−1 is given by +��Q−1�� ⩽ +1 +|Kbase| wmin +����� +∞ +� +i=1 +� +D−1 +Q EQ +�i +����� +⩽ +1 +|Kbase| wmin +1 +1 − +���D−1 +Q EQ +��� +⩽ +1 +|Kbase| wmin +1 +1 − +wmax +|Kbase|wmin += +1 +|Kbase| wmin − wmax +. +(21) +Substituting (21) into (19), we can derive that γ ⩾ 1 + +1 +ϑ log +� +1 − +4|Kadd|2w2 +max +|Kbase|wmin−wmax +� +. + diff --git a/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/load_file.txt b/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/load_file.txt new file mode 100644 index 0000000000000000000000000000000000000000..b008f4b5919ff36517e4f4a651f261dbf5dc7639 --- /dev/null +++ b/0dE3T4oBgHgl3EQfnAoC/content/tmp_files/load_file.txt @@ -0,0 +1,1035 @@ +filepath=/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf,len=1034 +page_content='arXiv:2301.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='04620v1 [eess.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='SY] 11 Jan 2023 AdaptSLAM: Edge-Assisted Adaptive SLAM with Resource Constraints via Uncertainty Minimization Ying Chen∗, Hazer Inaltekin†, Maria Gorlatova∗ ∗Duke University, Durham, NC, †Macquarie University, North Ryde, NSW, Australia ∗{ying.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='chen151, maria.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='gorlatova}@duke.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='edu, †hazer.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='inaltekin@mq.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='edu.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='au Abstract—Edge computing is increasingly proposed as a solu- tion for reducing resource consumption of mobile devices running simultaneous localization and mapping (SLAM) algorithms, with most edge-assisted SLAM systems assuming the communication resources between the mobile device and the edge server to be unlimited, or relying on heuristics to choose the information to be transmitted to the edge.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This paper presents AdaptSLAM, an edge-assisted visual (V) and visual-inertial (VI) SLAM system that adapts to the available communication and computation re- sources, based on a theoretically grounded method we developed to select the subset of keyframes (the representative frames) for constructing the best local and global maps in the mobile device and the edge server under resource constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We implemented AdaptSLAM to work with the state-of-the-art open-source V- and VI-SLAM ORB-SLAM3 framework, and demonstrated that, under constrained network bandwidth, AdaptSLAM reduces the tracking error by 62% compared to the best baseline method.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Index Terms—Simultaneous localization and mapping, edge computing, uncertainty quantification and minimization I.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' INTRODUCTION Simultaneous localization and mapping (SLAM), the pro- cess of simultaneously constructing a map of the environ- ment and tracking the mobile device’s pose within it, is an essential capability for a wide range of applications, such as autonomous driving and robotic navigation [1].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In partic- ular, visual (V) and visual-inertial (VI) SLAM, which use cameras either alone or in combination with inertial sensors, have demonstrated remarkable progress over the last three decades [2], and have become an indispensable component of emerging mobile applications such as drone-based surveil- lance [3], [4] and markerless augmented reality [5]–[8].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Due to the high computational demands placed by the V- and VI-SLAM on mobile devices [9]–[12], offloading parts of the workload to edge servers has recently emerged as a promis- ing solution for lessening the loads on the mobile devices and improving the overall performance [9]–[18].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' However, such approach experiences performance degradation under resource limitations and fluctuations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The existing edge-assisted SLAM solutions either assume wireless network resources to be sufficient for unrestricted offloading, or rely on heuristics in making offloading decisions.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' By contrast, in this paper we develop an edge computing-assisted SLAM framework, which we call AdaptSLAM, that intelligently adapts to both commu- nication and computation resources to maintain high SLAM performance.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Similar to prior work [11]–[17], AdaptSLAM runs a real-time tracking module and maintains a local map on the mobile device, while offloading non-time-critical and computationally expensive processes (global map optimization and loop closing) to the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' However, unlike prior designs, AdaptSLAM uses a theoretically grounded method to build the local and global maps of limited size, and minimize the uncertainty of the maps, laying the foundation for the optimal adaptive offloading of SLAM tasks under the communication and computation constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' First, we develop an uncertainty quantification model for the local and global maps in edge-assisted V-SLAM and VI- SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Specifically, since these maps are built from the infor- mation contained in the keyframes (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', the most representative frames) [19]–[21], the developed model characterizes how the keyframes and the connections between them contribute to the uncertainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' To the best of our knowledge, this is the first uncertainty quantification model for V-SLAM and VI-SLAM in edge-assisted architectures.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Next, we apply the developed uncertainty quantification model to efficiently select subsets of keyframes to build local and global maps under the constraints of limited computation and communication resources.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The local and global map construction is formulated as NP-hard cardinality-constrained combinatorial optimization problems [22].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We demonstrate that the map construction problems are ‘close to’ submodular problems under some conditions, propose a low-complexity greedy-based algorithm to obtain near-optimal solutions, and present a computation reuse method to speed up map construc- tion.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We implement AdaptSLAM in conjunction with the state- of-the-art open-source V- and VI-SLAM ORB-SLAM3 [20] framework, and evaluate the implementation with both sim- ulated and real-world communication and computation con- ditions.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Under constrained bandwidth, AdaptSLAM reduces the tracking error by 62% compared with the best baseline method.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' To summarize, the main contributions of this paper are: (i) the first uncertainty quantification model of maps in V- and VI-SLAM under the edge-assisted architecture, (ii) an analyt- ically grounded algorithm for efficiently selecting subsets of keyframes to build local and global maps under computation and communication resource budgets, and (iii) a compre- hensive evaluation of AdaptSLAM on two configurations of mobile devices.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We open-source AdaptSLAM via GitHub.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 The rest of this paper is organized as follows.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' §II reviews the related work, §III provides the preliminaries, §IV and 1https://github.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='com/i3tyc/AdaptSLAM §V introduce the AdaptSLAM system architecture and model, §VI presents the problem formulation, and §VII presents the problem solutions.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We present the evaluation in §VIII and conclude the paper in §IX.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' II.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' RELATED WORK V- and VI-SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Due to the affordability of cameras and the richness of information provided by them, V-SLAM has been widely studied in the past three decades [2].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It can be classified into direct approaches (LSD-SLAM [23], DSO [24]), which operate directly on pixel intensity values, and feature- based approaches (PTAM [25], ORB-SLAM2 [19], Pair- Navi [26]), which extract salient regions in each camera frame.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We focus on feature-based approaches since direct approaches require high computing power for real-time per- formance [2].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' To provide robustness (to textureless areas, motion blur, illumination changes), there is a growing trend of employing VI-SLAM, that assists the cameras with an inertial measurement unit (IMU) [20], [21], [27];' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' VI-SLAM has become the de-facto standard SLAM method for modern augmented reality platforms [5], [6].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In VI-SLAM, visual information and IMU data can be loosely [27] or tightly [20], [21] coupled.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We implement AdaptSLAM based on ORB- SLAM3 [20], a state-of-the-art open-source V- and VI-SLAM system which tightly integrates visual and IMU information.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Edge-assisted SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Recent studies [4], [9], [11], [13]– [18], [28]–[30] have focused on offloading parts of SLAM workloads from mobile devices to edge (or cloud) servers to reduce mobile device resource consumption.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A standard approach is to offload computationally expensive tasks (global map optimization, loop closing), while exploiting onboard computation for running the tasks critical to the mobile device’s autonomy (tracking, local map optimization) [11], [13]–[18].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Most edge-assisted SLAM frameworks assume wireless network resources to be sufficient for unconstrained offloading [4], [13]–[16], [29];' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' some use heuristics to choose the information to be offloaded under communication con- straints [9], [11], [17], [18], [28], [30].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Some frameworks only keep the newest keyframes in the local map to combat the constrained computation resources on mobile devices [14], [16].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Complementing this work, we propose a theoretical framework to characterize how keyframes contribute to the SLAM performance, laying the foundation for the adaptive offloading of SLAM tasks under the communication and computation constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Uncertainty quantification and minimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Recent work [31]–[33] has focused on quantifying and minimizing the pose estimate uncertainty in V-SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Since the pose estimate accuracy is difficult to obtain due to the lack of ground-truth poses of mobile devices, the uncertainty can guide the decision-making in SLAM systems.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In [31], [32], it is used for measurement selection (selecting measurements between keyframes [31] and selecting extracted features of keyframes [32]);' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' in [33], it is used for anchor selection (se- lecting keyframes to make their poses have ‘zero uncertainty’).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Complementing this work, we quantify the pose estimate uncertainty of both V- and VI-SLAM under the edge-assisted architecture.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' After the uncertainty quantification, we study the problem of selecting a subset of keyframes to minimize the uncertainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This problem is largely overlooked in the literature, but is of great importance for tackling computation and communication constraints in edge-assisted SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' III.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' PRELIMINARIES A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Graph Preliminaries A directed multigraph is defined by the tuple of sets G = (V, E, C), where V = {v1, · · · , v|V|} is the set of nodes, E is the set of edges, and C is the set of edge categories.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Let e = ((vi, vj), c) ∈ E denote the edge, where the nodes vi, vj ∈ V are the head and tail of e, and c ∈ C is the category of e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We let we be the weight of edge e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We allow multiple edges from vi to vj to exist, and denote the set of edges from vi to vj by Ei,j.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Note that the edges in Ei,j are differentiated from each other by their category labels.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The total edge weight from nodes vi to vj is given by wi,j = � e∈Ei,j we, which is the sum of all edge weights from vi to vj.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The weighted Laplacian matrix L of graph G is a |V| × |V| matrix where the i, j-th element Li,j is given by: Li,j = � −wi,j, i ̸= j � e∈Ei we, i = j , where Ei ⊆ E is the set of all edges whose head is node vi.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The reduced Laplacian matrix ˜L is obtained by removing an arbitrary node (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', removing the row and column associated to the node) from L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Set Function We define a set function f for a finite set V as a mapping f : 2V → R that assigns a value f (S) to each subset S ⊆ V .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Submodularity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A set function f is submodular if f (L) + f (S) ⩾ f (L ∪ S) + f (L ∩ S) for all L, S ⊆ V .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Submodularity ratio.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The submodularity ratio of a set function f with respect to a parameter s is γ = min L⊆V,S⊆V,|S|⩽s,x∈V \\(S∪L) f (L ∪ {x}) − f (L) f (L ∪ S ∪ {x}) − f (L ∪ S).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (1) where we define 0/0 := 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The cardinality-fixed maximization problem is max S⊆V,|S|=s f (S) .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (2) The keyframe selection optimization is closely related to the cardinality-fixed maximization problem introduced above, which is an NP-hard problem [34].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' However, for submodular set functions, there is an efficient greedy approach that will come close to the optimum value for (2), with a provable optimality gap.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This result is formally stated in Theorem 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Theorem 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [34], [35] Given a non-negative and monoton- ically increasing set function f with a submodularity ratio γ, let S# be the solution produced by the greedy algorithm (Algorithm 1) and S⋆ be the solution of (2).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Then, f � S#� ⩾ (1 − exp(−γ)) f (S⋆) .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' SLAM Preliminaries The components of SLAM systems include [2], [20], [21]: Tracking.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The tracking module detects 2D feature points (e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', by extracting SIFT, SURF, or ORB descriptors) in the current frame.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Each feature point corresponds to a 3D map point (e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', a distinguishable landmark) in the environment.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The tracking module uses these feature points to find corre- spondences with a previous reference frame.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It also processes the IMU measurements.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Based on the correspondences in feature points and the IMU measurements, it calculates the relative pose change between the selected reference frame and the current frame.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The module also determines if this frame should be a keyframe based on a set of criteria such as the similarity to the previous keyframes [20].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Local and global mapping.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It finds correspondences (of feature points) between the new keyframe and the other keyframes in the map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It then performs map optimizations, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', estimates the keyframe poses given the common feature points between the keyframes and the IMU measurements.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Map optimizations are computationally expensive.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In edge- assisted SLAM, global mapping runs on the server [11], [13]– [17].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Loop closing.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' By comparing the new keyframe to all previous keyframes, the module checks if the new keyframe is revisiting a place.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' If so (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', if a loop is detected), it establishes connections between the keyframe and all related previous ones, and then performs global map optimizations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Loop closing is computationally expensive and can be offloaded to the edge server in the edge-assisted SLAM [11], [13]–[17].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IV.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ADAPTSLAM SYSTEM ARCHITECTURE The design of AdaptSLAM is shown in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The mobile device, equipped with a camera and an IMU, can communicate with the edge server bidirectionally.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The mobile device and the edge server cooperatively run SLAM algorithms to estimate the mobile device’s pose and a map of the environment.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM optimizes the SLAM performance under compu- tation resource limits of the mobile device and communication resource limits between the mobile device and the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We split the modules between the mobile device and the edge server similar to [11], [13]–[18].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The mobile device offloads loop closing and global map optimization modules to the edge server, while running real-time tracking and local mapping onboard.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Unlike existing edge-assisted SLAM sys- tems [11], [13]–[18], AdaptSLAM aims to optimally construct the local and global maps under the computation and commu- nication resource constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The design of AdaptSLAM is Algorithm 1 Greedy algorithm to solve (2) 1: S# ← ∅;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2: while ( ��S#�� < s) do 3: x⋆ ← arg max x f(S#∪{x})−f(S#).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' S# ← S#∪{x⋆}.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mobile Device Edge Server Tracking Local Map Optimization Global Map Construction Global Map Optimization Loop Closing IMU Image Local Map Construction Candidate Keyframes Selected Keyframes Detected Loop Local Map Global Map Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1: Overview of the AdaptSLAM system architecture.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' mainly focused on two added modules, local map construction and global map construction highlighted in purple in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In local map construction, due to the computation resource limits, the mobile device selects a subset of keyframes from candidate keyframes to build a local map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In global map construction, to adapt to the constrained wireless connection for uplink transmission, the mobile device also selects a subset of keyframes to be transmitted to the edge server to build a global map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The AdaptSLAM optimally selects the keyframes to build local and global maps, minimizing the pose estimate uncertainty under the resource constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Similar to [11], the selected keyframes are transmitted from the mobile device to the server, and the map after the global map optimization is transmitted from the server to the mobile device.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the uplink transmission, instead of the whole keyframe, the 2D feature points extracted from the keyframes are sent.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the downlink communication, the poses of the keyframes obtained by the global map optimization, and the feature points of the keyframes are transmitted.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' V.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ADAPTSLAM SYSTEM MODEL A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The Pose Graph and the Map We divide time into slots of equal size of ∆t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We introduce the pose graph and the map at time slot t that lasts for ∆t seconds.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For clarity of notation, we will omit the time index below.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Definition 1 (Pose graph).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For a given index set K = {1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', |K|} (indexing camera poses and representing keyframes), the pose graph is defined as the undirected multi- graph G = (K, E, C), where K is the node set, E is the edge set, and C = {IMU, vis} is the category set.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Here, IMU stands for the IMU edges, and vis stands for the covisibility edges.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Given a pose graph G = (K, E, C), there is a camera pose Pn = (x, y, z, wx, wy, wz) for all n ∈ K, where the first three entries are the 3-D positions and the last three ones are the Euler angles (yaw, pitch and roll) representing the camera orientation.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Edges in E are represented as e = ((n, m), c) for n, m ∈ K and c ∈ C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Two keyframes in K are connected by a covisibility edge if there are 3D map points observed in both keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Two consecutive keyframes are connected by an IMU edge if there are accelerometer and gyroscope readings from one keyframe to another.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' There may exist both a covisibility edge and an IMU edge between two keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For each e = ((n, m), c) ∈ E, we observe relative noisy pose measurements between n and m, which is written as ∆e = Pm − Pn + xe, where xe is the measurement noise on edge e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The map optimization problem is to find the maximum likelihood estimates {˜Pn}n∈K for the actual camera poses {Pn}n∈K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For Gaussian distributed edge noise, the map optimization problem is min {˜Pn}n∈K � e∈E (˜xe)⊤Ie˜xe, (3) where ˜xe = ∆e − ˜Pm + ˜Pn and Ie is the information matrix (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', inverse covariance matrix) of the measurement error on e [36].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (˜xe)⊤ Ie˜xe is the Mahalanobis norm [20], [21] of the estimated measurement noise for e with respect to Ie.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Below, we assume that the measurement noise xe is Gaus- sian distributed with isotropic covariance (as in [31], [37], [38]).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We assume that the information matrix Ie can be characterized by a weight assigned to e [37], [39].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Specifically, Ie = weI, where we ⩾ 1 is the weight for e and I is the matrix that is constant for all measurements.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We note that the relative measurements between keyframes n and m introduce the same information for them.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We assume all weights we to be independent from each other for edges between different pairs of keyframes as in [20], [21], [39], [40].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The map optimization problem in (3) is solved by standard methods such as Levenberg-Marquardt algorithm implemented in g2o [41] and Ceres solvers [42] as in [20], [21].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Definition 2 (Anchor).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We say that a node is the anchor of the pose graph if the pose of the node is known.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The map (local or global) consists of the pose graph (in Definition 1) and map points in the environment.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In this paper, we will use the terms map and pose graph interchangeably.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Without loss of generality, we will also assume that the global (or local) map is anchored on the first node, as in [37], [39].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This assumption is made because SLAM can only estimate the relative pose change based on the covisibility and inertial measurements, while the absolute pose estimate in the global coordinate system cannot be provided.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The Local Map Local map construction.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The candidate keyframes are se- lected from camera frames according to the selection strategy in ORB-SLAM3 [20], and these candidate keyframes form the set K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Due to the constrained computation resources, the mobile device selects a fixed keyframe set Kfixed and a local keyframe set Kloc from the candidate keyframes, where |Kfixed| ⩽ lf and |Kloc| ⩽ lloc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The fixed keyframe set Kfixed ⊆ Kg,user is selected from the global map Kg,user that was last transmitted from the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The poses of keyframes in Kfixed act as fixed priors in the local map optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This is because poses of keyframes in Kg,user are already optimized in the global map optimization and hence have low uncertainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The poses of keyframes in the local keyframe set Kloc ⊆ K \\ Kg,user will be optimized according to the map optimization problem introduced above.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The edges between keyframes in Kloc form the set Eloc, and the edges whose one node belongs to Kloc and another node belongs to Kfixed form the set El,f.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Local map optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' After selecting Kloc in the local map construction, the local map optimization is to optimize the estimated poses � ˜Pn � n∈Kloc to minimize the sum of Mahalanobis norms � e∈Eloc∪El,f (˜xe)⊤Ie˜xe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Note that in the local pose graph optimization, the keyframes in Kfixed are included in the optimization with their poses fixed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The local map optimization to solve (3) is min {˜Pn}n∈Kloc � e∈Eloc∪El,f (˜xe)⊤Ie˜xe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (4) C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The Global Map Global map construction.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Due to the limited bandwidth between the mobile device and the edge server, only a subset of candidate keyframes are offloaded to the edge server to build a global map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The selection of keyframes to be offloaded will be optimized to minimize the pose estimation uncertainty of the global map when considering the underlying wireless network constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The edge server maintains the global map, denoted as Kg,edge, holding all keyframes uploaded by the mobile device.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The edges between keyframes in the global map Kg,edge constitute the set Eglob.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Note that Kg,edge may be different from Kg,user, because the global map is large and it takes time to transmit the most up-to-date global map from the edge server to the mobile device.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Global map optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' After selecting Kg,edge in the global map construction, the edge server performs the global map optimization to estimate poses ˜Pn in Kg,edge and minimize the sum of Mahalanobis norms � e∈Eglob (˜xe)⊤Ie˜xe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Specifically, the edge solves (3) when E = Eglob and K = Kg,edge, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', the global map optimization is to solve min {˜Pn}n∈Kg,edge � e∈Eglob (˜xe)⊤Ie˜xe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (5) VI.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' PROBLEM FORMULATION AdaptSLAM aims to efficiently select keyframes to con- struct optimal local and global maps, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', we select keyframes in Kloc and Kfixed for the local map and Kg,edge for the global map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From §IV, after constructing the optimal local and global maps, the map optimization can be performed using the standard algorithms [41], [42].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We construct optimal local and global maps by minimizing the uncertainty of the keyframes’ estimated poses.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, we represent and quantify the uncer- tainty in §VI-A, and formulate the uncertainty minimization problems in §VI-B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Uncertainty Quantification Let pn = ˜Pn − Pn denote the pose estimate error of keyframe n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The estimated measurement noise can be rewritten as �xe = pn − pm + xe = pn,m + xe, where pn,m = pn − pm.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We stack all pn, n ∈ K and get a pose estimate error vector w = � p⊤ 1 , p⊤ 2 , · · · , p⊤ |K| � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We rewrite the objective function of map optimization in (3) as � e∈E (˜xe)⊤Ie˜xe = � e=((n,m),c)∈E p⊤ n,mIepn,m + 2 � e=((n,m),c)∈E p⊤ n,mIexe + � e∈E x⊤ e Iexe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' If we can rewrite the quadratic term � e=((n,m),c)∈E p⊤ n,mIepn,m in the format of wIww⊤, where Iw is called the information matrix of the pose graph, the uncertainty of the pose graph is quantified by − log det (Iw) according to the D-optimality [31]–[33].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 We denote the pose estimate error vectors for the global and local maps as wg = � p⊤ u1, · · · , p⊤ u|Kg,edge| � and wl = � p⊤ r1, · · · , p⊤ r|Kloc| � , where u1, · · · , u|Kg,edge| are the keyframes in Kg,edge, and r1, · · · , r|Kloc| are the keyframes in Kloc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The first pose in the global and local pose graph is known (pu1 = 0, pr1 = 0).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We rewrite the quadratic terms of the objective functions of global and local map optimizations in (5) and (4) as � e=((n,m),c)∈Eglob p⊤ n,mIepn,m = wgIglob (Kg,edge) w⊤ g (or � e=((n,m),c)∈Eloc∪El,f p⊤ n,mIepn,m = wlIloc (Kloc, Kfixed)w⊤ l ), where Iglob (Kg,edge) and Iloc (Kloc, Kfixed) are called the information matrices of the global and local maps and will be derived later (in Definition 3 and Lemmas 1 and 2).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Definition 3 (Uncertainty).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The uncertainty of the global (or local) pose graph is defined as − log det � ˜Iglob (Kg,edge) � (or − log det � ˜Iloc (Kloc, Kfixed) � , where ˜Iglob (Kg,edge) and ˜Iloc (Kloc, Kfixed) are obtained by removing the first row and first column in the information matrices Iglob (Kg,edge) and Iloc (Kloc, Kfixed).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From Definition 3, the uncertainty quantification is based on the global and local map optimizations introduced in §V-C and §V-B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' After quantifying the uncertainty, we will later (in §VI-B) optimize the local and global map construction which in turn minimizes the uncertainty of poses obtained from local and global map optimizations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 1 (Uncertainty of global pose graph).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the global map optimization, the uncertainty is calculated as − log det � ˜Iglob (Kg,edge) � , where ˜Iglob (Kg,edge) = ˜Lglob⊗I with ˜Lglob being the matrix obtained by deleting the first row and column in the Laplacian matrix Lglob, and ⊗ being the Kronecker product.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The i, j-th element of Lglob is given by [Lglob]i,j = \uf8f1 \uf8f4 \uf8f2 \uf8f4 \uf8f3 − � e=((ui,uj),c)∈Eg,edge we, i ̸= j � e=((ui,q),c)∈Eg,edge,ui̸=q we, i = j .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (6) Proof.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' See Appendix A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof sketch: The proof follows from the global map optimization formulation in §V-C and the definition of ˜Iglob (Kg,edge).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2Common approaches to quantifying uncertainty in SLAM are to use real scalar functions of the maximum likelihood estimator covariance matrix [43].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Among them, D-optimality (determinant of the covariance matrix) [37], [39] captures the uncertainty due to all the elements of a covariance matrix and has well-known geometrical and information-theoretic interpretations [44].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From Lemma 1, the uncertainty of the global pose graph can be calculated based on the reduced Laplacian matrix (˜Lglob).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to the relationship between the reduced Laplacian matrix and the tree structure [45], the uncertainty is inversely proportional to the logarithm of weighted number of spanning trees in the global pose graph.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Similar conclusions are drawn for 2D pose graphs [31] and 3D pose graphs with only covisibility edges [37], [39], where the device can move in 2D plane and 3D space respectively.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We extend the results to VI-SLAM where the global pose graph is a multigraph with the possibility of having both a covisibility edge and an IMU edge between two keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 2 (Uncertainty of local pose graph).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The uncertainty is − log det � ˜Iloc (Kloc, Kfixed) � for the local map, where ˜Iloc (Kloc, Kfixed) = ˜Lloc ⊗ I with ˜Lloc being the matrix obtained by deleting the first row and the first column in Lloc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The i, j-th element of Lloc (of size |Kloc| × |Kloc|) is given by [Lloc]i,j = \uf8f1 \uf8f4 \uf8f2 \uf8f4 \uf8f3 − � e=((ri,rj),c)∈Eloc we, i ̸= j � e=((ri,q),c)∈El,f∪Eloc,q̸=ri we, i = j .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (7) Proof.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' See Appendix B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof sketch: Setting pn = 0, n ∈ Kfixed (the fixed keyframes have poses with ‘zero uncertainty’), the proof follows from the local pose graph optimization formulation in §V-B and the definition of ˜Iloc (Kloc, Kfixed).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From Lemma 2, the uncertainty of the local map is propor- tional to the uncertainty of the pose graph G anchoring on the first node in Kloc and all nodes in Kfixed, where G’s node set is Kfixed∪Kloc and edge set includes all measurements between any two nodes in Kfixed ∪ Kloc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Note that keyframe poses in Kfixed are optimized on the edge server and transmitted to the mobile device, and they are considered as constants in the local pose graph optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From the uncertainty’s perspective, adding fixed keyframes in Kfixed is equivalent to anchoring these keyframe poses (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', deleting rows and columns corresponding to the anchored nodes in the Laplacian matrix of graph G).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In addition, from Lemma 2, although poses are fixed, the anchored nodes still reduce the uncertainty of the pose graph.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, apart from Kloc, we will select the anchored keyframe set Kfixed to minimize the uncertainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Uncertainty Minimization Problems We now formulate optimization problems whose objectives are to minimize the uncertainty of the local and global maps.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the local map optimization, under the computation resource constraints, we solve Problem 1 for each keyframe k.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the global map optimization, under the communication resource constraints, we solve Problem 2 to adaptively offload keyframes to the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 1 (Local map construction).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' max Kloc,Kfixed log det � �Iloc (Kloc ∪ {k} , Kfixed) � (8) s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' |Kloc| ⩽ lloc, Kloc ⊆ K \\ Kg,user (9) |Kfixed| ⩽ lf, Kfixed ⊆ Kg,user.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (10) The objective of Problem 1 is equivalent to minimizing the uncertainty of the local map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Constraint (9) means that the size of Kloc is constrained to reduce the computational complexity in the local map optimization, and that the keyframes to be optimized in the local map are selected from keyframes that are not in Kg,user.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Constraint (10) means that the size of Kfixed is constrained, and that the fixed keyframes are selected from Kg,user that were previously optimized on and transmitted from the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 2 (Global map construction).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' max K′⊆K\\Kg,edge log det � �Iglob (Kg,edge ∪ K′) � (11) s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' d |K′| ⩽ D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (12) The objective of Problem 2 is equivalent to minimizing the uncertainty of the global map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' K \\ Kg,edge is set of the keyframes that have not been offloaded to the server, and we select a subset of keyframes, K′, from K \\ Kg,edge.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The constraint (12) guarantees that the keyframes cannot be offloaded from the device to the server at a higher bitrate than the available channel capacity, where D is the channel capacity constraint representing the maximum number of bits that can be transmitted in a given transmission window.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We assume that the data size d of each keyframe is the same, which is based on the observation that the data size is relatively consistent across keyframes in popular public SLAM datasets [46], [47].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' VII.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' LOCAL AND GLOBAL MAP CONSTRUCTION We analyze the properties of approximate submodularity in map construction problems, and propose low-complexity algorithms to efficiently construct local and global maps.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Local Map Construction The keyframes in the local map include those in two disjoint sets Kloc and Kfixed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' To efficiently solve Problem 1, we decompose it into two problems aiming at minimizing the uncertainty: Problem 3 that selects keyframes in Kloc and Problem 4 that selects keyframes in Kfixed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We obtain the optimal local keyframe set K⋆ loc in Problem 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Based on K⋆ loc, we then obtain the optimal fixed keyframe set K⋆ fixed in Problem 4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We will compare the solutions to Problems 3 and 4 with the optimal solution to Problem 1 in §VIII to show that the performance loss induced by the decomposition is small.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' K⋆ loc = arg max Kloc log det � ˜Iloc(Kloc∪ {k}, ∅) � s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (9).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' K⋆ fixed = arg max Kfixed log det � ˜Iloc(K⋆ loc∪ {k}, Kfixed) � s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (10).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1) The Selection of Local Keyframe Set Kloc: We first solve Problem 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It is a nonsubmodular optimization problem with constraints, which are NP-hard and generally difficult to be solved with an approximation ratio [22].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, we decompose Problem 3 into subproblems (Problems 5 and 6) that are equivalent to the original Problem 3 and can be approximately solved with a low-complexity algorithm.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In problem 5, assume that we already select a keyframe subset Kbase from K \\ Kg,user (with the size lb ≜ |Kbase| ⩽ lloc), and we aim to further select a keyframe set Kadd to be added to Kbase to minimize the local map uncer- tainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rewriting the objective as Unc (Kadd ∪ Kbase ∪ {k}) ≜ − log det � �Iloc (Kadd ∪ Kbase ∪ {k}, ∅) � , the problem is to obtain the optimal Kadd (denoted as OPTadd(Kbase)) given Kbase: Problem 5.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' OPTadd (Kbase) = arg max Kadd −Unc (Kadd ∪ Kbase ∪ {k}) s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' |Kadd| ⩽ lloc − lb.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' After getting the solutions (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', OPTadd (Kbase)) to Prob- lem 5 for all possible Kbase of size lb, we obtain the optimal Kbase (denoted as K⋆ base) in Problem 6.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 6.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' K⋆ base = arg max Kbase −Unc (OPTadd(Kbase) ∪ Kbase ∪ {k}) s.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='t.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' |Kbase| = lb.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Given lb, the solution to Problems 5 and 6, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', K⋆ base and OPTadd (K⋆ base), will give us the solution K⋆ loc to Problem 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Specifically, K⋆ loc = K⋆ base ∪ OPTadd (K⋆ base).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The proof is straightforward and hence omitted.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We can obtain K⋆ loc in Problem 3 by solving Problems 5 and 6.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We will show that the objective function of Problem 5 is ‘close to’ a submodular function when the size of the keyframe set Kbase is large.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In this case, Problem 5 can be efficiently solved using a greedy algorithm with an approximation ratio.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When |Kbase| is small, we need to compare the objective function for different combinations of Kbase and Kadd.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When wmax |Kbase|wmin < 1, the submodularity ratio γ of the objective function in Problem 5 is lower bounded by γ ⩾ 1 + 1 ϑ log � 1 − 4|Kadd|2w2 max |Kbase| wmin − wmax � , (13) where ϑ = min m∈Kadd � n∈Kbase log wn,m, wmax = max n,m∈Kbase∪Kadd wn,m, and wmin = min n,m∈Kbase∪Kadd wn,m.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' γ is close to 1 when |Kbase| is significantly larger than |Kadd|.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Algorithm 2 Selecting local keyframe set Kloc in the local map (top-h greedy-based algorithm) 1: Θ ← ∅;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2: while ( |Λ| ⩽ lloc) do 3: if |Λ| ⩽ lthr then h ← H else h ← 1;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4: Select the top-h highest-scoring combinations of Λ, Λ ∈ Θ and n, n ∈ K \\ Kg,user that minimize Unc (Λ ∪ {n, k}).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Unc (Λ ∪ {n, k}) is calculated using the computation reuse algorithm in Algorithm 2;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 5: Update Θ as the set of h highest-scoring combinations of Λ and n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Each element of Θ is a set (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', Λ ∪ {n}) corresponding to one combination;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 6: K⋆ loc ← arg min Λ∈Θ Unc(Λ ∪ {k}).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' See Appendix C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof sketch: Following from the definition of γ in (1), we first prove that the denomina- tor in (1), denoted as log det(Mden), is lower bounded by ϑ.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Denoting the numerator in (1) as log det(Mnum), we show that log det(Mnum) ⩾ log det(Mden) + log � 1 − 4|Kadd|2w2 max |Kbase|wmin−wmax � , by proving that the absolute val- ues of all elements in Mnum are bounded.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From Lemma 4, the objective function in Problem 5 is ‘close to’ a submodular function when the size of the exist- ing keyframe set (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', |Kbase|) is much larger than |Kadd|.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, we can use the greedy algorithm to approximately solve Problem 5.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to Theorem 1, the solution obtained by the greedy algorithm for Problem 5, denoted by OPT# add (Kbase), has an approximation guarantee that OPT# add (Kbase) ⩾ (1 − exp(−γ)) OPTadd (Kbase).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to the analysis of the properties of Problems 5 and 6, we now solve Problem 3 to select the local keyframe set Kloc using Algorithm 2 (top-h greedy-based algorithm).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Θ is the set of possible keyframe sets that minimize the local map uncertainty, and we only maintain h keyframe sets to save the computation resources.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Λ, Λ ∈ Θ, denotes the element in Θ and represents one possible keyframe set.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When the size of Λ is smaller than a threshold lthr (|Λ| ⩽ lthr), we select the top-H (H > 1) highest-scoring combinations of Λ and n, n ∈ K \\ Kg,user, that minimize Unc (Λ ∪ {k, n}).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When |Λ| gets larger, we only select the highest-scoring combination.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The reasons are as follows.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Λ can be seen as the existing keyframe set Kbase.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to Lemma 4, when the size of the existing keyframe set (which is |Λ| here) is small, there is no guarantee that Unc (Kadd ∪ Kbase ∪ {k}) is close to a submodular function (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', the submodularity ratio is much smaller than 1).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, we need to try different combinations of Λ and n to search for the combination that minimizes the uncertainty after each iteration.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' As |Λ| grows, the submodularity ratio is close to 1, and a greedy algorithm can achieve η approximation (η = 1 − exp(−γ), γ → 1).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In this case, we apply the greedy algorithm and only keep the combination that achieves the minimal uncertainty at each step.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Algorithm 3 Computation reuse algorithm 1: Input: det(A), A−1;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2: B ← A−1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calculate BiB⊤ i , i = 1, · · · , |Λ|;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3: Calculate (A′)−1 using (15).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calculate det (A′) using (16).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calculate det(˜I (Λ ∪ {n, k})) using (14).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2) Computation Reuse Algorithm: We use the computation reuse algorithm (Algorithm 3) to speed up Algorithm 2.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We observe that for different n, n ∈ K \\ Kg,user, only a limited number (3|Λ|+1) of elements in the matrix ˜I (Λ ∪ {n, k}) are different.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calculating the log-determinant function of a (|Λ|+ 1)×(|Λ|+1) matrix ˜I (Λ ∪ {n, k}) has a high computational complexity (of O(|Λ|+1)3) [48].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, instead of computing the objective function for each n from scratch, we reuse parts of computation results for different n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Letting A ≜ ˜I (Λ ∪ {k}) denote the information matrix of the local map in the |Λ|-th iteration (of Algorithm 2), the infor- mation matrix in the (|Λ|+1)-th iteration is ˜I (Λ ∪ {n, k}) = � A + diag (a) a⊤ a d � , where a = (a1, a2, · · · , a|Λ|) with ai = wλi,n, λi is the i-th element of Λ, and d = wk,n+ |Λ| � i=1 ai.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We aim to calculate det(˜I (Λ ∪ {n, k})) using the calcula- tion of det(A) and A−1 from the previous iteration.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Letting A′ ≜ A + diag(a), det(˜I (Λ ∪ {n, k})) is calculated by det(˜I (Λ ∪ {n, k})) = (d − a(A′)−1a⊤) det(A′).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (14) Next we efficiently calculate (A′)−1 and det(A′) to get det(˜I (Λ ∪ {n, k})).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We can rewrite A′ as A′ = A + |Λ| � i=1 β⊤ i βi where βi = \uf8eb \uf8ed0, · · · , √ai ���� i−th , · · · , 0 \uf8f6 \uf8f8.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to Sherman–Morrison formula [49], (A′)−1 is given by (A′)−1 ≈ B ���� Reuse − |Λ| � i=1 ai 1 + aiBi,i BiB⊤ i � �� � Reuse , (15) where B = A−1, Bi,i is the i, i-th element of B, and Bi is the i-th column vector of B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Using (15), B and BiB⊤ i can be computed only once to be used for different n, n ∈ K\\Kg,user, which greatly reduces the computational cost.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to the rank-1 update of determinant [49], det(A′) can be written as det (A′) = det (A) (1 + a1B1,1) {1(|Λ| = 1) + 1(|Λ| > 1) × |Λ| � i=2 \uf8eb \uf8ed1 + ai \uf8ee \uf8f0B − i−1 � j=1 ajBjBT j 1 + ajBj,j \uf8f9 \uf8fb i,i \uf8f6 \uf8f8 \uf8fc \uf8fd \uf8fe .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (16) � B − i−1 � j=1 ajBjBT j 1+ajBj,j � is already calculated in (15), which re- duces the computational complexity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Substituting (15) and (16) into (14), we get the final results of det(˜I (Λ ∪ {n, k})).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The computation complexity of different algorithms.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' If we select keyframes in Kloc using a brute-force algo- rithm based on exhaustive enumeration of combinations of keyframes in Kloc, the complexity is O �� ρ lloc � l3 loc � , where ρ = |K \\ Kg,user| is the number of keyframes that have not been offloaded to the edge server.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Without computation reuse, the computation complexity of the proposed top-h greedy- based algorithm is O(Hρl4 loc).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' With computation reuse, it is reduced to O(Hl4 loc) + O(Hρl3 loc).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Since we only keep lloc keyframes in Kloc of the local map and a small H in Algo- rithm 2 to save computation resources, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', ρ ≫ lloc > H, the proposed greedy-based algorithm with computation reuse significantly reduces the computational complexity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3) The Selection of Fixed Keyframe Set Kfixed: After selecting the local keyframe set Kloc by solving Problem 3, we solve Problem 4 to select the fixed keyframe set.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 5.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problem 4 is non-negative, monotone and submod- ular with a cardinality-fixed constraint.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof sketch.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' It is straightforward to prove the non-negativity and monotonicity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For the submodularity, we can prove that det(�Iloc(K⋆ loc∪{k},L)) det(�Iloc(K⋆ loc∪{k},S)) det(�Iloc(K⋆ loc∪{k},L∪S)) det(�Iloc(K⋆ loc∪{k},∅)) ⩾ 1, using the property that det(M) ⩾ det(N) holds for positive semidefi- nite matrices M, N when M−N is positive semidefinite.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lemma 5 indicates that the problem can be approximately solved with greedy methods in Algorithm 1 [34].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For each iteration, the algorithm selects one keyframe from Kg,user to be added to the fixed keyframe set Kfixed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The approximation ratio η = 1−exp(−1) guarantees that worst-case performance of a greedy algorithm cannot be far from optimal.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Global Map Construction We use a low-complexity algorithm to solve Problem 2 to construct the global map.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The objective function of Problem 2 can be rewritten as −Unc (Kg,edge ∪ K′), which has the same structure as that of Problem 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Problems 2 and 3 both add keyframes to the existing keyframe sets to construct a pose graph and optimize the keyframe poses in the pose graph.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, Algorithms 2 and 3 can be used to solve Problem 2.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In Algorithm 2, lloc is replaced by D d , and K \\ Kg,user is replaced by K \\ Kg,edge.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calculating the uncertainty of a large global map is computationally intensive, and hence the proposed low-complexity algorithm is essential to reducing the computational load on the mobile device.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' VIII.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' EVALUATION We implement AdaptSLAM on the open-source ORB- SLAM3 [20] framework which typically outperforms older SLAM methods [25], [26], with both V- and VI- configura- tions.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The edge server modules are run on a Dell XPS 8930 desktop with Intel (R) Core (TM) i7-9700K CPU@3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6GHz and NVIDIA GTX 1080 GPU under Ubuntu 18.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='04LTS.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In §VIII-A, the mobile device modules are run on the same desktop under simulated computation and network constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In §VIII-B, the mobile device modules are implemented on a laptop (with an AMD Ryzen 7 4800H CPU and an NVIDIA GTX 1660 Ti GPU), using a virtual machine with 4-core CPUs and 8GB of RAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The weight we, e = ((n, m), c) is set as the number of common map features visible in keyframes n and m for covisibility edges, similar to [20], [50], and the IMU edge weight is set as a large value (i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', 500) as the existence of IMU measurements greatly reduces the tracking error.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We empirically set H = 5 and lthr = 30 in Algorithm 2 to ensure low complexity and good performance at the same time.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Metric.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We use root mean square (RMS) absolute trajectory error (ATE) as the SLAM performance metric which is com- monly used in the literature [20], [51].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ATE is the absolute distance between the estimated and ground truth trajectories.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Baseline methods.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We compare AdaptSLAM with 5 base- lines.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Random selects the keyframe randomly.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' DropOldest drops the oldest keyframes when the number of keyframes is constrained.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ORBBuf, proposed in [28], chooses the keyframes that maximize the minimal edge weight between the adjacent selected keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' BruteForce examines all the combinations of keyframes to search for the optimal one that minimizes the uncertainty (in Problems 1 and 2).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' BruteForce can achieve better SLAM performance than AdaptSLAM but is shown to have exponential computation complexity in §VII-A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In the original ORB-SLAM3, the local map includes all covisibility keyframes, and the global map in- cludes all keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The original ORB-SLAM3 also achieves better SLAM performance and consumes more computation resources than AdaptSLAM as the numbers of keyframes in both local and global maps are large.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Datasets.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We evaluate AdaptSLAM on public SLAM datasets containing V and VI sequences, including TUM [47] and EuRoC [46].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The difficulty of a SLAM sequence depends on the extent of device mobility and scene illumination.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We use EuRoC sequences V101 (easy), V102 (medium), and V103 (difficult), and difficult TUM VI room1 and room6 sequences.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We report the results over 10 trials for each sequence.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Simulated Computation and Network Constraints First, we limit the number of keyframes in the local map under computation constraints, and all keyframes are used to build the global map without communication constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Second, we maintain local maps as in the default settings of ORB-SLAM3, and limit the number of keyframes in the global map under constrained communications, where D in Problem 2 is set according to the available bandwidth.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Local map construction.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We demonstrate the RMS ATE of different keyframe selection methods, for different V-SLAM (Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2a) and VI-SLAM (Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2b) sequences.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The size of the local map is limited to 10 keyframes and 9 anchors in V-SLAM sequences, and 25 keyframes and 10 anchors in VI-SLAM sequences (to ensure successful tracking while keeping a small local map).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM reduces the RMS ATE compared with Random, DropOldest, and ORBBuf by more than 70%, 62%, and 42%, averaged over all sequences.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The performance of AdaptSLAM is close to BruteForce, which demonstrates that our greedy-based algorithms yield near- optimal solutions, with substantially reduced computational complexity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Moreover, the performance of AdaptSLAM is close to the original ORB-SLAM3 (less than 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='05 m RMS ATE V101 V102 V103 room1 room6 Sequence 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 RMS ATE (m) Random DropOldest ORBBuf BruteForce ORB-SLAM3 AdaptSLAM (a) V-SLAM V101 V102 V103 room1 room6 Sequence 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 RMS ATE (m) Random DropOldest ORBBuf BruteForce ORB-SLAM3 AdaptSLAM (b) VI-SLAM Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2: RMS ATE for 6 keyframe selection methods in the local map construction for 5 sequences in EuRoC and TUM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Random DropOldest ORBBuf AdaptSLAM Method 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 RMS ATE (m) lloc = 10 lloc = 20 lloc = 30 Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3: RMS ATE for different sizes of local keyframe set (for EuRoC V102).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' V101 V102 V103 room1 room6 Sequence 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7 RMS ATE (m) Random DropOldest ORBBuf BruteForce ORB-SLAM3 AdaptSLAM (a) V-SLAM V101 V102 V103 room1 room6 Sequence 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 RMS ATE (m) Random DropOldest ORBBuf BruteForce ORB-SLAM3 AdaptSLAM (b) VI-SLAM Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4: RMS ATE for 6 keyframe selection methods in the global map construction for 5 sequences in EuRoC and TUM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Random DropOldest ORBBuf AdaptSLAM Method 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='8 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 RMS ATE (m) 40Mbps 80Mbps w/o bandwidth limitation Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 5: RMS ATE for different available bandwidth for offloading keyframes (for EuRoC V102).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' difference for all sequences) even though the size of the local map is reduced by more than 75%.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The influence of the number lloc of keyframes in the local map on the RMS ATE for different methods is shown in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We present the results for EuRoC V102 (of medium difficulty), which are representative.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When lloc is reduced from 30 to 10, AdaptSLAM increases the RMS ATE by only 6.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7%, to 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='09 m, as compared to 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='37, 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='16, and 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='12 m for, correspondingly, Random, DropOldest, and ORBBuf.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This indicates that AdaptSLAM achieves low tracking error under stringent computation resource constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Global map construction.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' First, we examine the case where only half of all keyframes are offloaded to build a global map, for V-SLAM (Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4a) and VI-SLAM (Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4b) sequences.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM reduces the RMS ATE compared with the closest baseline ORBBuf by 27% and 46% on average for V- and VI-SLAM, and has small performance loss compared with the original ORB-SLAM3, despite reducing the number of keyframes by half.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Next, in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 5, we examine four methods whose perfor- mance is impacted by the available bandwidth, under different levels of communication constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Without bandwidth lim- itations, all methods have the same performance as the global map holds all keyframes.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' When the bandwidth is limited, Random and DropOldest have the worst performance as they ignore the relations of keyframes in the pose graph.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The ORBBuf performs better, but the tracking error is increased by 4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0× and 9.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='8× when the bandwidth is limited to 80 and 40 Mbps.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM achieves the best performance, reducing the RMS ATE compared to ORBBuf by 62% and 78% when network bandwidth is 80 and 40 Mbps, correspondingly.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' This highlights the superiority of AdaptSLAM in achieving high tracking accuracy under communication constraints.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' foot1 foot3 foot5 Network trace 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='1 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='2 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7 RMS ATE (m) Random DropOldest ORBBuf AdaptSLAM Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 6: RMS ATE for dif- ference network traces.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Method Latency (ms) Random 133.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='0±86.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3 DropOldest 139.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='9±53.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7 ORBBuf 149.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3±75.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='6 BruteForce 863.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4±123.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='5 ORB-SLAM3 556.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='4±113.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7 AdaptSLAM 162.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='8±68.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='9 TABLE I: The latency for local map construction and optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Real-World Computation and Network Constraints Following the approach of splitting modules between the edge server and the mobile device [11], we split the modules as shown in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The server and the device are connected via a network cable to minimize other factors.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' To ensure reproducibility, we replay the network traces collected from a 4G network [52].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Focusing on mobile devices carried by users, we choose network traces (foot1, foot3, and foot5) collected by pedestrians.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We set D in Problem 2 according to the traces.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We examine the RMS ATE under the network traces in Fig.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 6 for the EuRoC V102 sequence.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The results for only four methods are presented because the overall time taken for running the SLAM modules onboard is high for BruteForce and the original SLAM.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM reduces the RMS ATE by 65%, 61%, and 35% (averaged over all traces) compared with Random, DropOldest, and ORBBuf.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM achieves high tracking accuracy under real-world network traces.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Table I shows the computation latency of mobile devices for all six methods.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We compare the latency for running local map construction and optimization, which is the main source of latency for modules running onboard [11].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Compared with AdaptSLAM, the original ORB-SLAM3 takes 3.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='7× as much time for optimizing the local map as all covisibility keyframes are included in the local map without keyframe selection.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Without the edge-assisted architecture, the original ORB-SLAM3 also runs global mapping and loop closing onboard which have even higher latency [11].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' BruteForce takes 5.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3× as much time for examining all the combinations of keyframes to minimize the local map uncertainty.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The latency for constructing and optimizing local maps using AdaptSLAM is close to that using Random and DropOldest (<12.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='3% difference).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Low latency for local mapping shows that edge- assisted SLAM is appealing, as local mapping is the biggest source of delay for modules executing onboard after offloading the intensive tasks (loop closing and global mapping).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IX.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' CONCLUSION We present AdaptSLAM, an edge-assisted SLAM that effi- ciently select subsets of keyframes to build local and global maps, under constrained communication and computation re- sources.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM quantifies the pose estimate uncertainty of V- and VI-SLAM under the edge-assisted architecture, and minimizes the uncertainty by low-complexity algorithms based on the approximate submodularity properties and computation reuse.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' AdaptSLAM is demonstrated to reduce the size of the local keyframe set by 75% compared with the original ORB- SLAM3 with a small performance loss.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ACKNOWLEDGMENTS This work was supported in part by NSF grants CSR- 1903136, CNS-1908051, and CNS-2112562, NSF CAREER Award IIS-2046072, by an IBM Faculty Award, and by the Australian Research Council under Grant DP200101627.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' REFERENCES [1] D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rosen, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Doherty, A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Ter´an Espinoza, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Leonard, “Advances in inference and representation for simultaneous localization and mapping,” Annu.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rev.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Control Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Auton.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Syst.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 215– 242, 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [2] C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cadena, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Carlone, H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Carrillo, Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Latif, D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Scaramuzza, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Neira, I.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Reid, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Leonard, “Past, present, and future of simultaneous localization and mapping: Toward the robust-perception age,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 32, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 6, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1309–1332, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [3] C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Forster, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lynen, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Kneip, and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Scaramuzza, “Collabora- tive monocular SLAM with multiple micro aerial vehicles,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2013.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [4] R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Williams, B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Konev, and F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Coenen, “Scalable distributed collabora- tive tracking and mapping with micro aerial vehicles,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2015.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [5] Google.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (2022) ARCore.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' https://developers.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='google.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='com/ar.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [6] Apple.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (2022) ARKit.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' https://developer.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='apple.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='com/augmented-reality/arkit/.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [7] T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Scargill, G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Premsankar, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chen, and M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Gorlatova, “Here to stay: A quantitative comparison of virtual object stability in markerless mobile AR,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/ACM Workshop on Cyber-Physical-Human System Design and Implementation, 2022.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [8] Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yeh and H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lin, “3D reconstruction and visual SLAM of indoor scenes for augmented reality application,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE ICCA, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [9] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Xu, H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cao, D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Li, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Qian, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Shangguan, and Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, “Edge assisted mobile semantic visual SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE INFO- COM, 2020.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [10] H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cao, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Xu, D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Li, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Shangguan, Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Liu, and Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, “Edge assisted mobile semantic visual SLAM,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mob.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Comput.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1–15, 2022.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [11] A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Ben Ali, Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hashemifar, and K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dantu, “Edge-SLAM: Edge- assisted visual simultaneous localization and mapping,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' ACM MobiSys, 2020.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [12] A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Ali, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Kouroshli, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Semenova, Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hashemifar, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Ko, and K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dantu, “Edge-SLAM: edge-assisted visual simultaneous localization and mapping,” ACM Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Embed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Comput.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Syst.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 22, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1–31, 2022.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [13] I.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Deutsch, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Liu, and R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Siegwart, “A framework for multi-robot pose graph SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE RCAR, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [14] M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Karrer, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Schmuck, and M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chli, “CVI-SLAM—collaborative visual- inertial SLAM,” IEEE Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Autom.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lett.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2762–2769, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [15] F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Li, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yi, and X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, “CORB-SLAM: a collaborative visual SLAM system for multiple robots,” in CollaborateCom.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Springer, 2017.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [16] P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Schmuck and M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chli, “CCM-SLAM: Robust and efficient centralized collaborative monocular simultaneous localization and mapping for robotic teams,” J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Field Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 36, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 763–781, 2019.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [17] K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wright, A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Sivakumar, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Steenkiste, B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yu, and F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Bai, “Cloud- SLAM: Edge offloading of stateful vehicular applications,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/ACM SEC, 2020.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [18] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Xu, H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cao, Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Shangguan, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhang, X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' He, and Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Liu, “SwarmMap: Scaling up real-time collaborative visual SLAM at the edge,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' USENIX NSDI, 2022.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [19] R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mur-Artal and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Tard´os, “ORB-SLAM2: An open-source SLAM system for monocular, stereo, and RGB-D cameras,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 33, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 5, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1255–1262, 2017.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [20] C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Campos, R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Elvira, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rodr´ıguez, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Montiel, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Tard´os, “ORB-SLAM3: An accurate open-source library for visual, visual–inertial, and multimap SLAM,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [21] T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Qin, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Li, and S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Shen, “VINS-Mono: A robust and versatile monocular visual-inertial state estimator,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 34, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1004–1020, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [22] A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Bian, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Buhmann, A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Krause, and S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Tschiatschek, “Guar- antees for greedy maximization of non-submodular functions with applications,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' PMLR ICML, 2017.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [23] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Engel, T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Sch¨ops, and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cremers, “LSD-SLAM: Large-scale direct monocular SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Springer ECCV, 2014.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [24] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Engel, V.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Koltun, and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cremers, “Direct sparse odometry,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Pattern Anal.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mach.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Intell.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 40, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 611–625, 2017.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [25] G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Klein and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Murray, “Parallel tracking and mapping for small AR workspaces,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE ISMAR, 2007.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [26] E.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dong, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Xu, C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wu, Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Liu, and Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yang, “Pair-Navi: Peer-to-peer indoor navigation with mobile visual SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE INFOCOM, 2019.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [27] S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Weiss, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' W.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Achtelik, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lynen, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chli, and R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Siegwart, “Real- time onboard visual-inertial state estimation and self-calibration of MAVs in unknown environments,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE ICRA, 2012.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [28] Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wang, Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zou, C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wang, Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dong, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Qiao, and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Manocha, “ORBBuf: A robust buffering method for remote visual SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [29] L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Riazuelo, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Civera, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Montiel, “C2TAM: A cloud framework for cooperative tracking and mapping,” Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Auton.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Syst.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 62, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 4, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 401–413, 2014.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [30] P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zeng, X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chen, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Luo, Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhou, and S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yu, “Edge robotics: Edge-computing-accelerated multi-robot simultaneous localization and mapping,” IEEE Internet Things J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', 2022.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [31] K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Khosoussi, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Giamou, G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Sukhatme, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dissanayake, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' How, “Reliable graphs for SLAM,” Int.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Res.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 38, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2-3, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 260–298, 2019.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [32] L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Carlone and S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Karaman, “Attention and anticipation in fast visual- inertial navigation,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 35, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1–20, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [33] Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chen, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhao, Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhang, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, and G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dissanayake, “Anchor selection for SLAM based on graph topology and submodular optimiza- tion,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [34] G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Nemhauser, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wolsey, and M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Fisher, “An analysis of approximations for maximizing submodular set functions—I,” Mathe- matical programming, vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 14, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 265–294, 1978.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [35] A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Das and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Kempe, “Approximate submodularity and its applications: Subset selection, sparse approximation and dictionary selection,” J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mach.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Learn.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Res.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 19, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 74–107, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [36] L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Carlone, G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Calafiore, C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Tommolillo, and F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dellaert, “Planar pose graph optimization: Duality, optimal solutions, and verification,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 32, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 545–565, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [37] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Placed and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Castellanos, “Fast autonomous robotic exploration using the underlying graph structure,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [38] K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Khosoussi, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, and G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dissanayake, “Tree-connectivity: Eval- uating the graphical structure of SLAM,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE ICRA, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [39] Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chen, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhao, and G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dissanayake, “Cram´er–Rao bounds and optimal design metrics for pose-graph SLAM,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 37, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 627–641, 2021.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [40] N.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Boumal, A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Singer, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='-A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Absil, and V.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Blondel, “Cram´er–Rao bounds for synchronization of rotations,” Information and Inference: A Journal of the IMA, vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1–39, 2014.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [41] R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' K¨ummerle, G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Grisetti, H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Strasdat, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Konolige, and W.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Burgard, “g2o: A general framework for graph optimization,” in IEEE ICRA, 2011.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [42] S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Agarwal, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Mierle, and Others, “Ceres solver,” http://ceres-solver.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='org.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [43] M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rodr´ıguez-Ar´evalo, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Neira, and J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Castellanos, “On the importance of uncertainty representation in active SLAM,” IEEE Trans.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 34, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 3, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 829–834, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [44] F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Pukelsheim, Optimal design of experiments.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' SIAM, 2006.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [45] K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Khosoussi, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, and G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Dissanayake, “Novel insights into the impact of graph structure on SLAM,” in IEEE/RSJ IROS, 2014.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [46] M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Burri, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Nikolic, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Gohl, T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Schneider, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rehder, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Omari, M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' W.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Achtelik, and R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Siegwart, “The EuRoC micro aerial vehicle datasets,” Int.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rob.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Res.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 35, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 10, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 1157–1163, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [47] D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Schubert, T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Goll, N.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Demmel, V.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Usenko, J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' St¨uckler, and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Cre- mers, “The TUM VI benchmark for evaluating visual-inertial odometry,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [48] G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Strang, Linear algebra and its applications.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Thomson, Brooks/Cole, 2006.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [49] G.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' H.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Golub and C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Van Loan, Matrix computations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' JHU press, 2013.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [50] Y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Chen, L.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhao, K.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' M.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lee, C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Yoo, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huang, and R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Fitch, “Broadcast your weaknesses: Cooperative active pose-graph SLAM for multiple robots,” IEEE Robot.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Autom.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lett, vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 5, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2200–2207, 2020.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [51] Z.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Zhang and D.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Scaramuzza, “A tutorial on quantitative trajectory evaluation for visual (-inertial) odometry,” in Proc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' IEEE/RSJ IROS, 2018.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' [52] J.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Van Der Hooft, S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Petrangeli, T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Wauters, R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Huysegems, P.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Alface, T.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Bostoen, and F.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' De Turck, “HTTP/2-based adaptive streaming of HEVC video over 4G/LTE networks,” IEEE Commun.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Lett.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=', vol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 20, no.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 11, pp.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' 2177–2180, 2016.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' APPENDIX A.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof of Lemma 1 The quadratic term of the objective function in (5) is � e=((n,m),c)∈Eglob p⊤ n,mIepn,m, where p⊤ n,mIepn,m can be rewritten as p⊤ n,mIepn,m =we � p⊤ n , p⊤ m � � I6I −I6I −I6I I6I � (pn, pm) =wgΞew⊤ g , (17) where the i, j-th block of Ξe, [Ξe]i,j, is derived as [Ξe]i,j = \uf8f1 \uf8f2 \uf8f3 −weI, ui = n, uj = m weI, ui = uj = n 0, otherwise .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' From the definition of Iglob (Kg,edge) and the global pose graph optimization formulation in §V-C, we can obtain that Iglob (Kg,edge) = � e∈Eg,edge Ξe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, Lglob is given by (6), which concludes the proof.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' B.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof of Lemma 2 As introduced in §V-B, the local pose graph optimization is to solve min { ˜Pn}n∈Kloc � e∈Eloc∪El,f (xe)⊤Iexe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' In optimizing poses of keyframes in Kloc, the poses of keyframes in Kfixed are fixed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, the quadratic term of the objective function can be rewritten as � e=((n,m),c)∈Eloc∪El,f p⊤ n,mIepn,m = � e=((n,m),c)∈Eloc p⊤ n,mIepn,m + � e=((n,m),c)∈El,f,n∈Kloc,m∈Kfixed p⊤ n Iepn + � e=((n,m),c)∈El,f,n∈Kfixed,m∈Kloc � −p⊤ m � Ie (−pm) .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to the above analysis, we can reformulate (4) as min { ˜Pn}n∈Kloc wlΛloc (Kloc, Kfixed) w⊤ l , where Λloc (Kloc, Kfixed) is the |Kloc| × |Kloc| block matrix whose i, j-th block is [Λloc (Kloc, Kfixed)]i,j = \uf8f1 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f2 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f4 \uf8f3 − � e=((ri,rj),c)∈Eloc weI, i ̸= j � � e=((ri,q),c)∈El,f,q∈Kfixed we + � e=((ri,q),c)∈Eloc,q∈Kloc,q̸=ri we � I , i = j .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' According to the uncertainty definition in Definition 3, the uncertainty of the local pose graph is calculated as − log det � ˜Iloc (Kloc, Kfixed) � , where ˜Iloc (Kloc, Kfixed) is given by (7).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' C.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Proof of Lemma 4 According to the definition of the submodularity ratio given in (1), the submodularity ratio γ of the objective function in Problem 5 can be calculated as (18), where (a) follows from the definition of the submodularity ratio.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' The denominator of (18), denoted as ς, is lower bounded by ς = log det � ˜Iloc (Kbase ∪ L ∪ S ∪ {x, k} , ∅) � det � ˜Iloc (Kbase ∪ L ∪ S ∪ {k}) , ∅ � ⩾ � n∈Kbase∪L∪S log wx,n ⩾ min m∈Kadd � n∈Kbase log wn,m ≜ ϑ, (20) where the first inequality is due to the fact that the determinant of the reduced weighted Laplacian matrix is equal to the tree- connectivity of its corresponding graph [31].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' γ (a) = min L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L −Unc (Kbase ∪ L ∪ {x}) + Unc (Kbase ∪ L) −Unc (Kbase ∪ L ∪ S ∪ {x}) + Unc (Kbase ∪ L ∪ S) = min L⊆Kadd,S⊆Kadd,|S|⩽lloc−lb,x∈Kadd,x̸∈S∪L log det(˜Iloc(Kbase∪L∪{x,k},∅)) det(˜Iloc(Kbase∪L∪{k}),∅) log det(˜Iloc(Kbase∪L∪S∪{x,k},∅)) det(˜Iloc(Kbase∪L∪S∪{k}),∅) .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (18) γ = 1 + log � min L⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='S⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='|S|⩽lloc−lb,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x∈Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x̸∈S∪L det(˜Iloc(Kbase∪L∪{x,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='k},' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='∅)) det(˜Iloc(Kbase∪L∪S∪{k}),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='∅) det(˜Iloc(Kbase∪L∪S∪{x,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='k},' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='∅)) det(˜Iloc(Kbase∪L∪{k}),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='∅) � ς = 1 + log \uf8eb \uf8ec \uf8ec \uf8ec \uf8ec \uf8ec \uf8ec \uf8ed min L⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='S⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='|S|⩽lloc−lb,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x∈Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x̸∈S∪L det \uf8eb \uf8ec \uf8ec \uf8ec \uf8ec \uf8ec \uf8ec \uf8ed \uf8eb \uf8ec \uf8ec \uf8edQ1+Q2+ \uf8ee \uf8ef\uf8ef\uf8f0 0z I|S| 0 \uf8f9 \uf8fa\uf8fa\uf8fb \uf8f6 \uf8f7 \uf8f7 \uf8f8 \uf8eb \uf8edQ1+Q3+ \uf8ee \uf8f0 0z+|S| 1 \uf8f9 \uf8fb \uf8f6 \uf8f8 (Q1+Q2+Q3+Q4) \uf8eb \uf8edQ1+ \uf8ee \uf8f0 0 0 0 I|S|+1 \uf8f9 \uf8fb \uf8f6 \uf8f8 \uf8f6 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f8 \uf8f6 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f7 \uf8f8 ς = 1 + log \uf8eb \uf8ec \uf8ec \uf8ed min L⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='S⊆Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='|S|⩽lloc−lb,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x∈Kadd,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content='x̸∈S∪L det (Q1)2+Q1Q2+Q1Q3+(Q2+Q3) \uf8ee \uf8f0 0 0 0 I|S|+1 \uf8f9 \uf8fb+Q2Q3 (Q1)2+Q1Q2+Q1Q3+(Q2+Q3) \uf8ee \uf8f0 0 0 0 I|S|+1 \uf8f9 \uf8fb+Q4 \uf8f6 \uf8f7 \uf8f7 \uf8f8 ς (a) ⩾ 1 + 1 ϑ log � 1 − g1Q−1g⊤ 1 � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (19) Substituting (20) into (18), γ can be further calculated by (19), where Ii and 0i are the i × i identity matrix and zero matrix, and Q = Q1 + Q2 + Q3 + Q4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Q1, Q2, Q3 and Q4 are defined as follows.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We express Kbase ∪ L ∪ S ∪ {x, k} as {si}i={1,··· ,z+|S|+2} where z = |Kbase ∪L|, si ∈ Kbase ∪L when i ⩽ z, si ∈ S when z < i ⩽ z + |S|, sz+|S|+1 = x, and sz+|S|+2 = k.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' For each edge e, we define a vector qe, and each element [qe]i = −[qe]j = we if vertexes si and sj are the head or tail of e and zero otherwise.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We then get ˜qe after removing the last element of qe.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Q1, Q2, Q3 and Q4 are defined as Q1 = 1 2 � e=((si,sj),c),si,sj∈Kbase∪L �qe�q⊤ e ( 1 2 is used because the edges from si to sj and from sj to si are both included), Q2 = � e=((si,x),c),si∈Kbase∪L �qe�q⊤ e , Q3 = � e=((si,sj),c),si∈Kbase∪L,sj∈S �qe�q⊤ e , and Q4 = � e=((x,sj),c),sj∈S �qe�q⊤ e .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' g1 is given by g1 = \uf8ee \uf8f00, · · · , 0 � �� � z ‘0′s , −wx,s1, · · · , −wx,s|S| |S| � i=1 wx,si \uf8f9 \uf8fb , where wmax = max n,m∈Kbase∪Kadd wn,m, and wx,si ⩽ wmax for si ∈ S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (a) in (19) is because for invertible positive semidefinite matrices M, N, det(M) ⩾ det(N) holds when M − N is positive semidefinite [48].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' We will prove that ��Q−1�� ⩽ 1 |Kbase|wmin−wmax when |Kbase| is significantly larger than |Kadd|, where ∥M∥ is the l∞ norm of M (defined as the largest magnitude among each element in M), and wmin = min n,m∈Kbase∪Kadd wn,m.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Rewrite Q as Q = DQ − EQ, where DQ is a diagonal matrix with elements on the diagonal the same as those of Q, and EQ = DQ − Q.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Q−1 is calculated as Q−1 = � Iz+|S|+1 − D−1 Q EQ �−1 D−1 Q = � ∞ � i=0 � D−1 Q EQ �i � D−1 Q .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' D−1 Q EQ has the properties that all elements in D−1 Q EQ are positive and smaller than wmax |Kbase|wmin , and all row vectors has an l∞ norm smaller than 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Hence, we have ���� � D−1 Q EQ �i���� ⩽ wmax |Kbase|wmin .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' Q−1 is given by ��Q−1�� ⩽ 1 |Kbase| wmin ����� ∞ � i=1 � D−1 Q EQ �i ����� ⩽ 1 |Kbase| wmin 1 1 − ���D−1 Q EQ ��� ⩽ 1 |Kbase| wmin 1 1 − wmax |Kbase|wmin = 1 |Kbase| wmin − wmax .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} +page_content=' (21) Substituting (21) into (19), we can derive that γ ⩾ 1 + 1 ϑ log � 1 − 4|Kadd|2w2 max |Kbase|wmin−wmax � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dE3T4oBgHgl3EQfnAoC/content/2301.04620v1.pdf'} diff --git a/0dFST4oBgHgl3EQfVTiq/content/tmp_files/2301.13777v1.pdf.txt b/0dFST4oBgHgl3EQfVTiq/content/tmp_files/2301.13777v1.pdf.txt new file mode 100644 index 0000000000000000000000000000000000000000..843b737fe8904acfe7cb269e05e6b8ec390dae78 --- /dev/null +++ b/0dFST4oBgHgl3EQfVTiq/content/tmp_files/2301.13777v1.pdf.txt @@ -0,0 +1,1263 @@ +Computer Algebra in R Bridges a Gap Between Mathematics and Data +in the Teaching of Statistics and Data Science +Mikkel Meyer Andersen and Søren Højsgaard +February 1, 2023 +Mikkel Meyer Andersen +Department of Mathematical Sciences, Aalborg University, Denmark +Skjernvej 4A +9220 Aalborg Ø, Denmark +ORCiD: 0000-0002-0234-0266 +mikl@ math. aau. dk +Søren Højsgaard +Department of Mathematical Sciences, Aalborg University, Denmark +Skjernvej 4A +9220 Aalborg Ø, Denmark +ORCiD: 0000-0002-3269-9552 +sorenh@ math. aau. dk +Abstract +The capability of R to do symbolic mathematics is enhanced by the caracas package. This package +uses the Python computer algebra library SymPy as a back-end but caracas is tightly integrated in +the R environment, thereby enabling the R user with symbolic mathematics within R. We demonstrate +how mathematics and statistics can benefit from bridging computer algebra and data via R. This is done +thought a number of examples and we propose some topics for small student projects. The caracas +package integrates well with e.g. Rmarkdown, and as such creation of scientific reports and teaching is +supported. +Introduction +The caracas package [Andersen and Højsgaard, 2021] and the Ryacas package [Andersen and Højsgaard, +2019] enhance the capability of R [R Core Team, 2023] to handle symbolic mathematics. In this paper +we will illustrate the use of the caracas package in connection with teaching mathematics and statistics. +Focus is on 1) treating statistical models symbolically, 2) on bridging the gap between symbolic mathe- +matics and numerical computations and 3) on preparing teaching material in a reproducible framework +(provided by, e.g. rmarkdown [Allaire et al., 2021, Xie et al., 2018, 2020]. The caracas package is avail- +able from CRAN [R Core Team, 2023]. The open-source development version of caracas is available +at https://github.com/r-cas/caracas and readers are recommended to study the online documenta- +tion at https://r-cas.github.io/caracas/. The caracas package provides an interface from R to the +Python package sympy [Meurer et al., 2017]. This means that SymPy is “running under the hood” of R +via the reticulate package [Ushey et al., 2020]. The sympy package is mature and robust with many +users and developers. +Neither caracas nor Ryacas are as powerful as some of the larger commercial computer algebra +systems (CAS). The virtue of caracas and Ryacas lie elsewhere: (1) Mathematical tools like equation +solving, summation, limits, symbolic linear algebra, outputting in tex format etc. are directly available +from within R. (2) The packages enable working with the same language and in the same environment +as the user does for statistical analyses. (3) Symbolic mathematics can easily be combined with data +which is helpful in e.g. numerical optimization. (4) The packages are open-source and therefore support +1 +arXiv:2301.13777v1 [stat.AP] 31 Jan 2023 + +e.g. education - also for people with limited economical means and thus contributing to United Nations +sustainable development goals [United Nations General Assembly, 2015]. +The paper is organized in the following sections: The section Mathematics and documents containing +mathematics briefly introduces the caracas package and its syntax, including how caracas can be used in +connection with preparing texts, e.g. teaching material. More details are provided in the Section Important +technical aspects. Several vignettes illustrating caracas are provided and they are also available online, +see https://r-cas.github.io/caracas/. The section Statistics examples is the main section of the +paper and here we present a sample of statistical models where we believe that a symbolic treatment is +a valuable supplement to a numerical in connection with teaching. The section Possible topics to study +contains suggestions about hand-on activities for students. Lastly, the section Discussion and future work +contains a discussion of the paper. +Mathematics and documents containing mathematics +We start by introducing the caracas syntax on familiar topics within calculus and linear algebra. +Calculus +First we define a caracas symbol x (more details will follow in Section Important technical aspects) and +subsequently a caracas polynomial p in x (p becomes a symbol because x is): +R> library(caracas) +R> def_sym(x) ## Declares ’x’ as a symbol +R> p <- 1 - x^2 + x^3 + x^4/4 - 3 * x^5 / 5 + x^6 / 6 +R> p +#> [c]: +6 +5 +4 +#> +x +3*x +x +3 +2 +#> +-- - ---- + -- + x +- x ++ 1 +#> +6 +5 +4 +The gradient of p is: +R> grad <- der(p, x) ## ’der’ is shorthand for derivative +R> grad +#> [c]: +5 +4 +3 +2 +#> +x +- 3*x ++ x ++ 3*x +- 2*x +Stationary points of p can be found by finding roots of the gradient. In this simple case we can factor +the gradient: +R> factor_(grad) +#> [c]: +2 +#> +x*(x - 2)*(x - 1) *(x + 1) +The factorizations shows that stationary points are −1, 0, 1 and 2. To investigate if extreme points +are local minima, local maxima or saddle points, we compute the Hessian and evaluate the Hessian in the +stationary points: +R> hess <- der2(p, x) +R> hess +#> [c]: +4 +3 +2 +#> +5*x +- 12*x ++ 3*x ++ 6*x - 2 +R> hess_ <- as_func(hess) +R> hess_ +2 + +#> function (x) +#> { +#> +5 * x^4 - 12 * x^3 + 3 * x^2 + 6 * x - 2 +#> } +#> +R> stationary_points <- c(-1, 0, 1, 2) +R> hess_(stationary_points) +#> [1] 12 -2 +0 +6 +Alternatively, we can create an R expression and evaluate: +R> eval(as_expr(hess), list(x = stationary_points)) +#> [1] 12 -2 +0 +6 +The sign of the Hessian in these points gives that x = −1 and x = 12 are local minima, x = 0 is a local +maximum and x = 1 is a saddle point. In general we can find the stationary symbolically and evaluate +the Hessian as follows (output omitted): +R> sol <- solve_sys(lhs = grad, vars = x) ## finds roots by default +R> subs(hess, sol[[1]]) ## the first solution +R> lapply(sol, function(s) subs(hess, s)) ## iterate over all solutions +Linear algebra +Next, we create a symbolic matrix and find its inverse: +R> M <- as_sym(toeplitz(c("a", "b", 0))) ## as_sym() converts an R object to caracas symbol +R> Minv <- inv(M) %>% simplify() +Default printing of M is (Minv is shown below in next section): +R> M +#> [c]: [a +b +0] +#> +[ +] +#> +[b +a +b] +#> +[ +] +#> +[0 +b +a] +A vector is a one-column matrix, but it is printed as its transpose to save space: +R> v <- vector_sym(3, "v") +R> v +#> [c]: [v1 +v2 +v3]^T +Matrix products are computed using the %*% operator: +R> M %*% v +#> [c]: [a*v1 + b*v2 +a*v2 + b*v1 + b*v3 +a*v3 + b*v2]^T +3 + +Preparing mathematical documents +The packages Sweave [Leisch, 2002] and Rmarkdown [Allaire et al., 2021] provide integration of LaTeX +and other text formatting systems into R helping to produce text document with R content. In a similar +vein, caracas provides an integration of computer algebra into R and in addition, caracas also facilitates +creation of documents with mathematical content without e.g. typing tedious LaTeX instructions. +A LaTeX rendering of the caracas symbol p is obtained by typing $$p(x) = `r tex(p)`$$ which +results in the following when the document is compiled: +p(x) = x6 +6 − 3x5 +5 ++ x4 +4 + x3 − x2 + 1 +Typing $$Mˆ{-1} = `r tex(Minv)`$$ produces the result: +M −1 = +� +�� +a2−b2 +a(a2−2b2) +− +b +a2−2b2 +b2 +a(a2−2b2) +− +b +a2−2b2 +a +a2−2b2 +− +b +a2−2b2 +b2 +a(a2−2b2) +− +b +a2−2b2 +a2−b2 +a(a2−2b2) +� +�� . +The determinant of M is det(M) = a3 −2∗a∗b2 and this can be factored out of the matrix by dividing +each entry with the determinant and multiplying the new matrix by the determinant which simplifies the +appearance of the matrix: +R> Minv_fact <- as_factor_list(1 / factor_(det(M)), simplify(Minv * det(M))) +Typing $$Mˆ{-1} = `r tex(Minv_fact)`$$ produces this: +M −1 = +1 +a (a2 − 2b2) +� +� +a2 − b2 +−ab +b2 +−ab +a2 +−ab +b2 +−ab +a2 − b2 +� +� . +Finally we illustrate creation of additional mathematical expressions: +R> def_sym(x, n) +R> y <- (1 + x/n)^n +R> lim(y, n, Inf) +#> [c]: exp(x) +Typing $$y = `r tex(y)`$$ etc. gives +y = +� +1 + x +n +�n +, lim +n−>∞ y = exp(x). +We can also prepare unevaluated expressions using the doit argument. That helps making repro- +ducible documents where the changes in code appears automatically in the generated formulas. This is +done as follows: +R> l <- lim(y, n, Inf, doit = FALSE) +R> l +#> [c]: +n +#> +/ +x\ +#> +lim |1 + -| +#> +n->oo\ +n/ +R> doit(l) +#> [c]: exp(x) +Typing $$`r tex(l)` = `r tex(doit(l))`$$ gives +lim +n→∞ +� +1 + x +n +�n += ex. +Several functions have the doit argument, e.g. lim(), int() and sum_(). +4 + +Important technical aspects +A caracas symbol is a list with a pyobj slot and the class caracas_symbol. The pyobj is an an object +in Python (often a sympy object). As such, a symbol (in R) provides a handle to a Python object. In +the design of caracas we have tried to make this distinction something the user should not be concerned +with, but it is worthwhile being aware of the distinction. +Sections Calculus and Linear algebra illustrate that caracas symbols can be created with def_sym() +and as_sym(). Both declares the symbol in R and in Python. A symbol can also be defined in terms of +other symbols: Define symbols s1 and s2 and define symbol s3 in terms of s1 and s2: +R> def_sym(s1, s2) ## Note: ’s1’ and ’s2’ exist in both R and Python +R> s1$pyobj +#> s1 +R> s3_ <- s1 * s2 +## Note: ’s3’ is a symbol in R; no corresponding object in Python +R> s3_$pyobj +#> s1*s2 +The underscore in s3_ indicates that this expression is defined in terms of other symbols. +This +convention is used through out the paper. Next express s1 and s2 in terms of symbols u and v (which +are created on the fly): +R> s4_ <- subs(s3_, c("s1", "s2"), c("u+v", "u-v")) +R> s4_ +#> [c]: (u - v)*(u + v) +Statistics examples +In this section we examine larger statistical examples and demonstrate how caracas can help improve +understanding of the models. +Linear models +A matrix algebra approach to e.g. linear models is very clear and concise. On the other hand, it can also +be argued that matrix algebra obscures what is being computed. Numerical examples are useful for some +aspects of the computations but not for other. In this respect symbolic computations can be enlightening. +Consider a two-way analysis of variance (ANOVA) with one observation per group, see Table 1. +Table 1: Two-by-two layout of data. +y11 +y21 +y12 +y22 +R> nr <- 2 +R> nc <- 2 +R> y <- matrix_sym(nr, nc, "y") +R> dim(y) <- c(nr*nc, 1) +R> y +#> [c]: [y11 +y21 +y12 +y22]^T +R> dat <- expand.grid(r=factor(1:nr), s=factor(1:nc)) +R> X <- model.matrix(~r+s, data=dat) |> as_sym() +R> b <- vector_sym(ncol(X), "b") +R> mu <- X %*% b +5 + +For the specific model we have random variables y = (yij). All yijs are assumed independent and +yij ∼ N(µij, v). The corresponding mean vector µ has the form given below: +y = +� +��� +y11 +y21 +y12 +y22 +� +��� , +X = +� +��� +1 +. +. +1 +1 +. +1 +. +1 +1 +1 +1 +� +��� , +b = +� +� +b1 +b2 +b3 +� +� , +µ = Xb = +� +��� +b1 +b1 + b2 +b1 + b3 +b1 + b2 + b3 +� +��� . +Above and elsewhere, dots represent zero. The least squares estimate of b is the vector ˆb that minimizes +||y − Xb||2 which leads to the normal equations (X⊤X)b = X⊤y to be solved. If X has full rank, the +unique solution to the normal equations is ˆb = (X⊤X)−1X⊤y. +Hence the estimated mean vector is +ˆµ = Xˆb = X(X⊤X)−1X⊤y. Symbolic computations are not needed for quantities involving only the +model matrix X, but when it comes to computations involving y, a symbolic treatment of y is useful: +R> XtX <- t(X) %*% X +R> XtXinv <- inv(XtX) +R> Xty <- t(X) %*% y +R> b_hat <- XtXinv %*% Xty +X⊤y = +� +� +y11 + y12 + y21 + y22 +y21 + y22 +y12 + y22 +� +� , +ˆb = 1 +4 +� +� +3y11 + y12 + y21 − y22 +−2y11 − 2y12 + 2y21 + 2y22 +−2y11 + 2y12 − 2y21 + 2y22 +� +� +(1) +Hence X⊤y (a sufficient reduction of data if the variance is known) consists of the sum of all observa- +tions, the sum of observations in the second row and the sum of observations in the second column. For +ˆb, the second component is, apart from a scaling, the sum of the second row minus the sum of the first +row. Likewise, the third component is the sum of the second column minus the sum of the first column. +It is hard to give an interpretation of the first component of ˆb. +Logistic regression +In the following we go through details of a logistic regression model, see e.g. McCullagh and Nelder [1989] +for a classical description of logistic regression: Observables are binomially distributed, yi ∼ bin(pi, ni). +The probability pi is connected to a q-vector of covariates xi = (xi1, . . . , xiq) and a q-vector of regression +coefficients b = (b1, . . . , bq) as follows: The term si = xi ·b is denoted the linear predictor. The probability +pi can be linked to si in different ways, but the most commonly employed is via the logit link function +which is logit(pi) = log(pi/(1 − pi)) so here logit(pi) = si. +As an example, consider the budworm data from the doBy package [Højsgaard and Halekoh, 2023]. +The data shows the number of killed moth tobacco budworm Heliothis virescens. Batches of 20 moths of +each sex were exposed for three days to the pyrethroid and the number in each batch that were dead or +knocked down was recorded: +R> data(budworm, package = "doBy") +R> bud <- subset(budworm, sex == "male") +R> bud +#> +sex dose ndead ntotal +#> 1 male +1 +1 +20 +#> 2 male +2 +4 +20 +#> 3 male +4 +9 +20 +#> 4 male +8 +13 +20 +#> 5 male +16 +18 +20 +#> 6 male +32 +20 +20 +Below we focus only on male budworms and the mortality is illustrated in Figure 1 (produced with +ggplot2 [Wickham, 2016]). On the y-axis we have the empirical logits, i.e. log((ndead + 0.5)/(ntotal − +ndead + 0.5)). The figure suggests that logit grows linearly with log dose. +6 + +−2 +0 +2 +4 +0 +10 +20 +30 +dose +Empirical logits +−2 +0 +2 +4 +0 +1 +2 +3 +4 +5 +log2(dose) +Empirical logits +Figure 1: Insecticide mortality of the moth tobacco budworm. +Each component of the likelihood +The log-likelihood is log L = � +i yi log(pi)+(ni−yi) log(1−pi) = � +i log Li, say. With log(pi/(1−pi)) = si +we have pi = 1/(1 + exp(−si)) and +d +dsi pi = +exp(−si) +(1+exp(−si))2 . With si = xi · b, we have +d +dbsi = xi. +Consider the contribution to the total log-likelihood from the ith observation which is li = yi log(pi)+ +(ni − yi) log(1 − pi). Since we are focusing on one observation only, we shall ignore the subscript i in this +section. First notice that with s = log(p/(1 − p)) we can find p as: +R> def_sym(s, p) +R> sol_ <- solve_sys(lhs = log(p / (1 - p)), rhs = s, vars = p) +R> sol_[[1]]$p +#> [c]: +exp(s) +#> +---------- +#> +exp(s) + 1 +Next, find the likelihood as a function of p, as a function of s and as a function of b. The underscore +in logLb_ and elsewhere indicates that this expression is defined in terms of other symbols (this is in +contrast to the free variables, e.g. y, p, and n.): +R> def_sym(y, n, p, x, s, b) +R> logLp_ <- y * log(p) + (n - y) * log(1 - p) +R> p_ <- exp(s) / (exp(s) + 1) +R> logLs_ <- subs(logLp_, p, p_) +R> s_ <- sum(x * b) +R> logLb_ <- subs(logLs_, s, s_) +R> logLb_ +#> [c]: +/ +exp(b*x) +\ +/ +exp(b*x) +\ +#> +y*log|------------| + (n - y)*log|1 - ------------| +#> +\exp(b*x) + 1/ +\ +exp(b*x) + 1/ +The log-likelihood can be maximized using e.g. Newton-Rapson (see e.g. Nocedal and Wright [2006]) +and in this connection we need the score function, S, and the Hessian, H: +R> Sb_ <- score(logLb_, b) |> simplify() +R> Hb_ <- hessian(logLb_, b) |> simplify() +R> Sb_ +#> [c]: [x*(y - (n - y)*exp(b*x))] +#> +[------------------------] +#> +[ +exp(b*x) + 1 +] +R> Hb_ +7 + +#> [c]: [ +2 +] +#> +[ +-n*x *exp(b*x) +] +#> +[---------------------------] +#> +[exp(2*b*x) + 2*exp(b*x) + 1] +Since x and b are vectors, the term b*x above should be read as the inner product x · b (or as x⊤b in +matrix notation). Also, since x is a vector, the term xˆ2 above should be read as the outer product x ⊗ x +(or as xx⊤ in matrix notation). More insight in the structure is obtained by letting b and x be 2-vectors +(to save space, the Hessian matrix is omitted in the following): +R> b <- vector_sym(2, "b") +R> x <- vector_sym(2, "x") +R> s_ <- sum(x * b) +R> logLb_ <- subs(logLs_, s, s_) +R> Sb_ <- score(logLb_, b) |> simplify() +logLb_ = y log +� +eb1x1+b2x2 +eb1x1+b2x2 + 1 +� ++ (n − y) log +� +1 − +eb1x1+b2x2 +eb1x1+b2x2 + 1 +� +, +(2) +Sb_ = +� +� +x1(−neb1x1+b2x2+yeb1x1+b2x2+y) +eb1x1+b2x2+1 +x2(−neb1x1+b2x2+yeb1x1+b2x2+y) +eb1x1+b2x2+1 +� +� . +(3) +Next, insert data, e.g. x1 = 1, x2 = 2, y = 9, n = 20 to obtain a function of the regression parameters +only. Note how the expression depending on other symbols, S_, is named S. to indicate that data has +been inserted: +R> nms <- c("x1", "x2", "y", "n") +R> vls <- c(1, 2, 9, 20) +R> logLb. <- subs(logLb_, nms, vls) +R> Sb. <- subs(Sb_, nms, vls) +The total score for the entire dataset can be obtained as follows: +R> Sb_list <- lapply(seq_len(nrow(bud)), function(r){ ++ +vls <- c(1, log2(bud$dose[r]), bud$ndead[r], bud$ntotal[r]) ++ +subs(Sb_, nms, vls) ++ }) +R> Sb_total <- Reduce(‘+‘, Sb_list) +This score can be used as part of an iterative algorithm for solving the score equations. If one wants to +use Newton-Rapson, the total Hessian matrix must also be created following lines similar to those above. +It is straight forward implement a Newton-Rapson algorithm based on these quantities, one must only +note the distinction between the two expressions below (and it is the latter one would use in an iterative +algorithm): +R> subs(Sb_total, b, c(1, 2)) +R> subs(Sb_total, b, c(1, 2)) |> as_expr() +An alternative is to construct the total log-likelihood for the entire dataset as a caracas object, convert +this object to an R function and maximize this function using one of R’s optimization methods: +R> logLb_list <- lapply(seq_len(nrow(bud)), function(r){ ++ +vls <- c(1, log2(bud$dose[r]), bud$ndead[r], bud$ntotal[r]) ++ +subs(logLb_, nms, vls) ++ }) +R> logLb_total <- Reduce(‘+‘, logLb_list) +R> logLb_total_func <- as_func(logLb_total, vec_arg = TRUE) +8 + +The total likelihood symbolically +We conclude this section by illustrating that the log-likelihood for the entire dataset can be constructed +in a few steps (output is omitted to save space): +R> X. <- as_sym(cbind(1, log2(bud$dose))) +R> n. <- as_sym(bud$ntotal) +R> y. <- as_sym(bud$ndead) +R> N <- nrow(X.) +R> q <- ncol(X.) +R> X <- matrix_sym(N, q, "x") +R> n <- vector_sym(N, "n") +R> y <- vector_sym(N, "y") +R> p <- vector_sym(N, "p") +R> s <- vector_sym(N, "s") +R> b <- vector_sym(q, "b") +X = +� +������� +x11 +x12 +x21 +x22 +x31 +x32 +x41 +x42 +x51 +x52 +x61 +x62 +� +������� +, +X. = +� +������� +1 +0 +1 +1 +1 +2 +1 +3 +1 +4 +1 +5 +� +������� +, +n. = +� +������� +20 +20 +20 +20 +20 +20 +� +������� +, +n = +� +������� +n1 +n2 +n3 +n4 +n5 +n6 +� +������� +, +y. = +� +������� +1 +4 +9 +13 +18 +20 +� +������� +. +The symbolic computations are as follows: +R> ## log-likelihood as function of p +R> logLp +<- sum(y * log(p) + (n-y) * log(1-p)) +R> ## log-likelihood as function of s +R> p_ <- exp(s) / (exp(s) + 1) +R> logLs <- subs(logLp, p, p_) +R> ## linear predictor as function of regression coefficients: +R> s_ +<- X %*% b +R> ## log-Likelihood as function of regression coefficients: +R> logLb <- subs(logLs, s, s_) +Next, numerical values can be inserted: +R> logLb <- subs(logLb, cbind(n, y, X), cbind(n., y., X.)) +An alternative would have been to define logLp above in terms of n. and y. and similarly define +s_ in terms of X. If doing so, the last step where numerical values are inserted could have been avoided. +From here, one may proceed by computing the score function and the Hessian matrix and solve the +score equation, using e.g. Newton-Rapson. Alternatively, one might create an R function based on the +log-likelihood, and maximize this function using one of R’s optimization methods (see the example in the +previous section): +R> logLb_func <- as_func(logLb, vec_arg = TRUE) +R> optim(c(0, 0), logLb_func, control = list(fnscale = -1), hessian = TRUE) +Maximum likelihood under constraints +In this section we illustrate constrained optimization using Lagrange multipliers. This is demonstrated +for the independence model for a two-way contingency table. Consider a 2 × 2 contingency table with +cell counts yij and cell probabilities pij for i = 1, 2 and j = 1, 2, where i refers to row and j to column as +illustrated in Table 1. +Under multinomial sampling, the log likelihood is +l = log L = +� +ij +yij log(pij). +9 + +Under the assumption of independence between rows and columns, the cell probabilities have the form, +(see e.g. Højsgaard et al. [2012], p. 32) +pij = u · ri · sj. +To make the parameters (u, ri, sj) identifiable, constraints must be imposed. One possibility is to +require that r1 = s1 = 1. The task is then to estimate u, r2, s2 by maximizing the log likelihood under +the constraint that � +ij pij = 1. This can be achieved using a Lagrange multiplier where we instead solve +the unconstrained optimization problem maxp Lag(p) where +Lag(p) = −l(p) + λg(p) +under the constraint that +(4) +g(p) = +� +ij +pij − 1 = 0, +(5) +where λ is a Lagrange multiplier. In SymPy, lambda is a reserved symbol. Hence the underscore as postfix +below: +R> y_ <- c("y_11", "y_21", "y_12", "y_22") +R> y +<- as_sym(y_) +R> def_sym(u, r2, s2, lambda_) +R> p <- as_sym(c("u", "u*r2", "u*s2", "u*r2*s2")) +R> logL +<- sum(y * log(p)) +R> Lag +<- -logL + lambda_ * (sum(p) - 1) +R> vars <- list(u, r2, s2, lambda_) +R> gLag <- der(Lag, vars) +R> sol <- solve_sys(gLag, vars) +R> print(sol, method = "ascii") +#> Solution 1: +#> +lambda_ = +y_11 + y_12 + y_21 + y_22 +#> +r2 += +(y_21 + y_22)/(y_11 + y_12) +#> +s2 += +(y_12 + y_22)/(y_11 + y_21) +#> +u += +(y_11 + y_12)*(y_11 + y_21)/(y_11 + y_12 + y_21 + y_22)^2 +R> sol <- sol[[1]] +There is only one critical point. Fitted cell probabilities ˆpij are: +R> p11 <- sol$u +R> p21 <- sol$u * sol$r2 +R> p12 <- sol$u * sol$s2 +R> p22 <- sol$u * sol$r2 * sol$s2 +R> p.hat <- matrix_(c(p11, p21, p12, p22), nrow = 2) +ˆp = +1 +(y11 + y12 + y21 + y22)2 +� +(y11 + y12) (y11 + y21) +(y11 + y12) (y12 + y22) +(y11 + y21) (y21 + y22) +(y12 + y22) (y21 + y22) +� +To verify that the maximum likelihood estimate has been found, we compute the Hessian matrix which +is negative definite (the Hessian matrix is diagonal so the eigenvalues are the diagonal entries and these +are all negative), output omitted: +R> H <- hessian(logL, list(u, r2, s2)) |> simplify() +An AR(1) model +Symbolic computations +In this section we study the auto regressive model of order 1 (an AR(1) model), see e.g. Shumway and +Stoffer [2016], p. 75 ff. for details: Consider random variables x1, x2, . . . , xn following a stationary zero +mean AR(1) process: +xi = axi−1 + ei; +i = 2, . . . , n, +(6) +10 + +where ei ∼ N(0, v) and all eis are independent. Note that v denotes the variance. The marginal +distribution of x1 is also assumed normal, and for the process to be stationary we must have that the +variance Var(x1) = v/(1 − a2). Hence we can write x1 = +1 +√ +1−a2 e1. +For simplicity of exposition, we set n = 4. All terms e1, . . . , e4 are independent and N(0, v) distributed. +Let e = (e1, . . . , e4) and x = (x1, . . . x4). Hence e ∼ N(0, vI). Isolating error terms in (6) gives +e = +� +��� +e1 +e2 +e3 +e4 +� +��� = +� +��� +√ +1 − a2 +. +. +. +−a +1 +. +. +. +−a +1 +. +. +. +−a +1 +� +��� +� +��� +x1 +x2 +x3 +x4 +� +��� = Lx. +Since Var(e) = vI we have Var(e) = vI = LVar(x)L′ so the covariance matrix of x is V = Var(x) = +vL−(L−)⊤ while the concentration matrix (the inverse covariance matrix) is K = v−1L⊤L: +R> n <- 4 +R> L <- diff_mat(n, "-a") +R> def_sym(a) +R> L[1, 1] <- sqrt(1-a^2) +R> def_sym(v) +R> Linv <- inv(L) +R> K <- crossprod_(L) / v +R> V <- tcrossprod_(Linv) * v +L−1 = +� +���� +1 +√ +1−a2 +. +. +. +a +√ +1−a2 +1 +. +. +a2 +√ +1−a2 +a +1 +. +a3 +√ +1−a2 +a2 +a +1 +� +���� , +(7) +K = 1 +v +� +��� +1 +−a +. +. +−a +a2 + 1 +−a +. +. +−a +a2 + 1 +−a +. +. +−a +1 +� +��� , +(8) +V = v +� +���� +1 +1−a2 +a +1−a2 +a2 +1−a2 +a3 +1−a2 +a +1−a2 +a2 +1−a2 + 1 +a3 +1−a2 + a +a4 +1−a2 + a2 +a2 +1−a2 +a3 +1−a2 + a +a4 +1−a2 + a2 + 1 +a5 +1−a2 + a3 + a +a3 +1−a2 +a4 +1−a2 + a2 +a5 +1−a2 + a3 + a +a6 +1−a2 + a4 + a2 + 1 +� +���� . +(9) +The zeros in the concentration matrix K implies a conditional independence restriction: If the ijth +element of a concentration matrix is zero then xi and xj are conditionally independent given all other +variables, see e.g. Højsgaard et al. [2012], p. 84 for details. +Next, we take the step from symbolic computations to numerical evaluations. The joint distribution +of x is multivariate normal distribution, x ∼ N(0, K−1). Let W = xx⊤ denote the matrix of (cross) +products. The log-likelihood is therefore (ignoring additive constants) +log L = n +2 (log det(K) − x⊤Kx) = n +2 (log det(K) − tr(KW)), +where we note that tr(KW) is the sum of the elementwise products of K and W since both matrices +are symmetric. Ignoring the constant n +2 , this can be written symbolically to obtain the expression in this +particular case: +R> x <- vector_sym(n, "x") +R> logL <- log(det(K)) - sum(K * (x %*% t(x))) %>% simplify() +log L = log +� +−a2 +v4 + 1 +v4 +� +− −2ax1x2 − 2ax2x3 − 2ax3x4 + x2 +1 + x2 +2 +� +a2 + 1 +� ++ x2 +3 +� +a2 + 1 +� ++ x2 +4 +v +. +11 + +Numerical evaluation +Next we illustrate how bridge the gap from symbolic computations to numerical computations based on +a dataset: For a specific data vector we get: +R> xt <- c(0.1, -0.9, 0.4, .0) +R> logL. <- subs(logL, x, xt) +log L = log +� +−a2 +v4 + 1 +v4 +� +− 0.97a2 + 0.9a + 0.98 +v +. +We can use R for numerical maximization of the likelihood and constraints on the parameter values +can be imposed e.g. in the optim() function: +R> logL_wrap <- as_func(logL., vec_arg = TRUE) +R> eps <- 0.01 +R> par <- optim(c(a=0, v=1), logL_wrap, ++ +lower=c(-(1-eps), eps), upper=c((1-eps), 10), ++ +method="L-BFGS-B", control=list(fnscale=-1))$par +R> par +#> +a +v +#> -0.376 +0.195 +The same model can be fitted e.g. using R’s arima() function as follows (output omitted): +R> arima(xt, order = c(1, 0, 0), include.mean = FALSE, method = "ML") +It is less trivial to do the optimization in caracas by solving the score equations. There are some +possibilities for putting assumptions on variables in caracas (see the “Reference” vignette), but it is not +possible to restrict the parameter a to only take values in (−1, 1). +Variance of the average of correlated data +Consider random variables x1, . . . , xn where Var(xi) = v and Cov(xi, xj) = vr for i ̸= j, where 0 ≤ |r| ≤ +1. For n = 3, the covariance matrix of (x1, . . . , xn) is therefore +V = vR = v +� +� +1 +r +r +r +1 +r +r +r +1 +� +� . +(10) +Let ¯x = � +i xi/n denote the average. Suppose interest is in the variance of the average, Var(¯x), when +n goes to infinity. One approach is as follow: Let 1 denote an n-vector of 1’s and let V be an n × n +matrix with v on the diagonal and vr outside the diagonal. Then Var(¯x) = +1 +n2 1⊤V 1. The answer lies in +studying the limiting behaviour of this expression when n → ∞. First, we must calculate variance of a +sum x. = � +i xi which is Var(x.) = � +i Var(xi) + 2 � +ij:i def_sym(v, r, n, j, i) +R> var_sum <- v*(n + 2*sum_(sum_(r, j, i+1, n), i, 1, n-1)) |> simplify() +R> var_avg <- var_sum / n^2 +Var(x.) = nv (r (n − 1) + 1) , +Var(¯x) = v (r (n − 1) + 1) +n +. +From hereof, we can study the limiting behavior of the variance Var(¯x) in different situations: +R> l_1 <- lim(var_avg, n, Inf) +## when sample size n goes to infinity +R> l_2 <- lim(var_avg, r, 0, dir=’+’) +## when correlation r goes to zero +R> l_3 <- lim(var_avg, r, 1, dir=’-’) +## when correlation r goes to one +12 + +For a given correlation r it is instructive to investigate how many independent variables k the n +correlated variables correspond to (in the sense of the same variance of the average), because the k can +be seen as a measure of the amount of information in data. Moreover, one might study how k behaves +as function of n when n → ∞. That is we must (1) solve v(1 + (n − 1)r)/n = v/k for k and (2) find +limn→∞ k: +R> def_sym(k) +R> k <- solve_sys(var_avg - v / k, k)[[1]]$k +R> l_k <- lim(k, n, Inf) +The findings above are: +l1 = rv, +l2 = v +n, +l3 = v, +k = +n +nr − r + 1, +lk = 1 +r . +With respect to k, it is illustrative to supplement the symbolic computations above with numerical +evaluations, which shows that even a moderate correlation reduces the effective sample size substantially: +R> dat <- expand.grid(r=c(.1, .2, .5), n=c(10, 50)) +R> k_fun <- as_func(k) +R> dat$k <- k_fun(r=dat$r, n=dat$n) +R> dat$ri <- 1/dat$r +R> dat +#> +r +n +k ri +#> 1 0.1 10 5.26 10 +#> 2 0.2 10 3.57 +5 +#> 3 0.5 10 1.82 +2 +#> 4 0.1 50 8.47 10 +#> 5 0.2 50 4.63 +5 +#> 6 0.5 50 1.96 +2 +Possible topics to study +1. Related to Section Linear models: +a) The orthogonal projection matrix onto the span of the model matrix X is P = X(X⊤X)−1X⊤. +The residuals are r = (I − P)y. From this one may verify that these are not all independent. +b) If one of the factors is ignored, then the model becomes a one-way analysis of variance model, +at it is illustrative to redo the computations in Section Linear models in this setting. +c) Likewise if an interaction between the two factors is included in the model. +What are the +residuals in this case? +2. Related to Section Logistic regression: +a) In Each component of the likelihood, Newton-Rapson can be implemented to solve the likelihood +equations and compared to the output from glm(). +Note how sensitive Newton-Rapson is +to starting point. +This can be solved by another optimisation scheme, e.g. +Nelder-Mead +(optimising the log likelihood) or BFGS (finding extreme for the score function). +b) The example is done as logistic regression with the logit link function. Try other link functions +such as cloglog (complementary log-log). +3. Related to Section Maximum likelihood under constraints: +a) Identifiability of the parameters was handled by not including r1 and s1 in the specification +of pij. An alternative is to impose the restrictions r1 = 1 and s1 = 1, and this can also be +handled via Lagrange multipliers. Another alternative is to regard the model as a log-linear +model where log pij = log u + log ri + log sj = ˜u + ˜ri + ˜sj. This model is similar in its structure +to the two-way ANOVA for Section Linear models. This model can be fitted as a generalized +linear model with a Poisson likelihood and log as link function. Hence, one may modify the +results in Section Logistic regression to provide an alternative way of fitting the model. +b) A simpler task is to consider a multinomial distribution with four categories, counts yi and cell +probabilities pi, i = 1, 2, 3, 4 where � +i pi = 1. For this model, find the maximum likelihood +estimate for pi (use the Hessian to verify that the critical point is a maximum). +13 + +4. Related to Section An AR(1) model: +a) Compare the estimated parameter values with those obtained from the arima() function. +b) Modify the model in Equation (6) by setting x1 = axn + e1 (“wrapping around”) and see what +happens to the pattern of zeros in the concentration matrix. +c) Extend the AR(1) model to an AR(2) model (“wrapping around”) and investigate this model +along the same lines. Specifically, where are the conditional independencies (try at least n = 6)? +5. Related to Section Variance of the average of correlated data: It is illustrative to study such be- +haviours for other covariance functions. Replicate the calculations for the covariance matrix of the +form +V = vR = v +� +��� +1 +r +0 +0 +r +1 +r +0 +0 +r +1 +r +0 +0 +r +1 +� +��� , +(11) +i.e., a special case of a Toeplitz matrix. How many independent variables, k, do the n correlated +variables correspond to? +Discussion and future work +We have presented the caracas package and argued that the package extends the functionality of R sig- +nificantly with respect to symbolic mathematics. One practical virtue of caracas is that the package +integrates nicely with Rmarkdown, Allaire et al. [2021], (e.g. with the tex() functionality) and thus sup- +ports creating of scientific documents and teaching material. As for the usability in practice we await +feedback from users. +Another related package we mentioned in the introduction is Ryacas. This package has existed for +many years and is still of relevance. Ryacas probably has fewer features than caracas. On the other hand, +Ryacas does not require Python (it is compiled), is faster for some computations (like matrix inversion). +Finally, the Yacas language [Pinkus and Winitzki, 2002, Pinkus et al., 2016] is extendable (see e.g. the +vignette “User-defined yacas rules” in the Ryacas package). +One possible future development could be an R package which is designed without a view towards the +underlying engine (SymPy or Yacas) and which then draws more freely from SymPy and Yacas. In this +connection we mention that there are additional resources on CRAN such as calculus [Guidotti, 2022]. +Lastly, with respect to freely available resources in a CAS context, we would like to draw attention +to WolframAlpha, see https://www.wolframalpha.com/, which provides an online service for answering +(mathematical) queries. +Acknowledgements +We would like to thank the R Consortium for financial support for creating the caracas package, users +for pin pointing points that can be improved in caracas and Ege Rubak (Aalborg University, Denmark), +Malte Bødkergaard Nielsen (Aalborg University, Denmark), and Poul Svante Eriksen (Aalborg University, +Denmark) for comments on this manuscript. +References +J. Allaire, Y. Xie, J. McPherson, J. Luraschi, K. Ushey, A. Atkins, H. Wickham, J. Cheng, W. Chang, +and R. Iannone. rmarkdown: Dynamic Documents for R, 2021. URL https://github.com/rstudio/ +rmarkdown. R package version 2.7. 1, 4, 14 +M. M. Andersen and S. Højsgaard. Ryacas: A computer algebra system in R. Journal of Open Source +Software, 4(42), 2019. URL https://doi.org/10.21105/joss.01763. 1 +M. M. Andersen and S. Højsgaard. caracas: Computer algebra in R. Journal of Open Source Software, 6 +(63):3438, 2021. doi: 10.21105/joss.03438. URL https://doi.org/10.21105/joss.03438. 1 +E. Guidotti. calculus: High-Dimensional Numerical and Symbolic Calculus in R. Journal of Statistical +Software, 104(1):1–37, 2022. doi: 10.18637/jss.v104.i05. URL https://www.jstatsoft.org/index. +php/jss/article/view/v104i05. 14 +14 + +S. Højsgaard, D. Edwards, and S. Lauritzen. Graphical Models with R. Springer, New York, 2012. doi: +10.1007/978-1-4614-2299-0. ISBN 978-1-4614-2298-3. 10, 11 +S. Højsgaard and U. Halekoh. doBy: Groupwise Statistics, LSmeans, Linear Estimates, Utilities, 2023. +URL https://github.com/hojsgaard/doby. R package version 4.6.16. 6 +F. Leisch. Sweave: Dynamic generation of statistical reports using literate data analysis. In W. Härdle +and B. Rönz, editors, Compstat, pages 575–580, Heidelberg, 2002. Physica-Verlag HD. 4 +P. McCullagh and J. A. Nelder. Generalized Linear Models. Chapman & Hall/CRC Monographs on +Statistics and Applied Probability. Chapman & Hall/CRC, Philadelphia, PA, 2 edition, Aug. 1989. +ISBN 9780412317606. 6 +A. Meurer, C. P. Smith, M. Paprocki, O. Čertík, S. B. Kirpichev, M. Rocklin, A. Kumar, S. Ivanov, J. K. +Moore, S. Singh, T. Rathnayake, S. Vig, B. E. Granger, R. P. Muller, F. Bonazzi, H. Gupta, S. Vats, +F. Johansson, F. Pedregosa, M. J. Curry, A. R. Terrel, v. Roučka, A. Saboo, I. Fernando, S. Kulal, +R. Cimrman, and A. Scopatz. Sympy: symbolic computing in python. PeerJ Computer Science, 3: +e103, Jan. 2017. ISSN 2376-5992. doi: 10.7717/peerj-cs.103. URL https://doi.org/10.7717/peerj- +cs.103. 1 +J. Nocedal and S. J. Wright. [Numerical Optimization. Springer New York, 2006. doi: 10.1007/978-0- +387-40065-5. URL https://doi.org/10.1007/978-0-387-40065-5. 7 +A. Pinkus, S. Winnitzky, and G. Mazur. Yacas - yet another computer algebra system. Technical report, +2016. URL https://yacas.readthedocs.io/en/latest/. 14 +A. Z. Pinkus and S. Winitzki. YACAS: A Do-It-Yourself Symbolic Algebra Environment. In Proceedings +of the Joint International Conferences on Artificial Intelligence, Automated Reasoning, and Symbolic +Computation, AISC ’02/Calculemus ’02, pages 332–336, London, UK, UK, 2002. Springer-Verlag. ISBN +3-540-43865-3. doi: 10.1007/3-540-45470-5_29. URL http://doi.org/10.1007/3-540-45470-5_29. +14 +R Core Team. R: A Language and Environment for Statistical Computing. R Foundation for Statistical +Computing, Vienna, Austria, 2023. URL http://www.R-project.org/. ISBN 3-900051-07-0. 1 +R. H. Shumway and D. S. Stoffer. Time Series Analysis and Its Applications. Springer, fourth edition +edition, 2016. 10 +United Nations General Assembly. Sustainable development goals, 2015. https://sdgs.un.org/. 2 +K. Ushey, J. Allaire, and Y. Tang. +reticulate: Interface to ’Python’, 2020. +URL https://CRAN.R- +project.org/package=reticulate. R package version 1.18. 1 +H. Wickham. +ggplot2: Elegant Graphics for Data Analysis. +Springer-Verlag New York, 2016. +ISBN +978-3-319-24277-4. URL https://ggplot2.tidyverse.org. 6 +Y. Xie, J. Allaire, and G. Grolemund. R Markdown: The Definitive Guide. Chapman and Hall/CRC, +Boca Raton, Florida, 2018. URL https://bookdown.org/yihui/rmarkdown. ISBN 9781138359338. 1 +Y. Xie, C. Dervieux, and E. Riederer. R Markdown Cookbook. Chapman and Hall/CRC, Boca Raton, +Florida, 2020. URL https://bookdown.org/yihui/rmarkdown-cookbook. ISBN 9780367563837. 1 +15 + diff --git a/0dFST4oBgHgl3EQfVTiq/content/tmp_files/load_file.txt b/0dFST4oBgHgl3EQfVTiq/content/tmp_files/load_file.txt new file mode 100644 index 0000000000000000000000000000000000000000..adcb2cb6f74b7f456eb81318fe0b450120881adb --- /dev/null +++ b/0dFST4oBgHgl3EQfVTiq/content/tmp_files/load_file.txt @@ -0,0 +1,680 @@ +filepath=/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf,len=679 +page_content='Computer Algebra in R Bridges a Gap Between Mathematics and Data in the Teaching of Statistics and Data Science Mikkel Meyer Andersen and Søren Højsgaard February 1, 2023 Mikkel Meyer Andersen Department of Mathematical Sciences, Aalborg University, Denmark Skjernvej 4A 9220 Aalborg Ø, Denmark ORCiD: 0000-0002-0234-0266 mikl@ math.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' aau.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' dk Søren Højsgaard Department of Mathematical Sciences, Aalborg University, Denmark Skjernvej 4A 9220 Aalborg Ø, Denmark ORCiD: 0000-0002-3269-9552 sorenh@ math.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' aau.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' dk Abstract The capability of R to do symbolic mathematics is enhanced by the caracas package.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This package uses the Python computer algebra library SymPy as a back-end but caracas is tightly integrated in the R environment, thereby enabling the R user with symbolic mathematics within R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' We demonstrate how mathematics and statistics can benefit from bridging computer algebra and data via R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This is done thought a number of examples and we propose some topics for small student projects.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The caracas package integrates well with e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Rmarkdown, and as such creation of scientific reports and teaching is supported.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Introduction The caracas package [Andersen and Højsgaard, 2021] and the Ryacas package [Andersen and Højsgaard, 2019] enhance the capability of R [R Core Team, 2023] to handle symbolic mathematics.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In this paper we will illustrate the use of the caracas package in connection with teaching mathematics and statistics.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Focus is on 1) treating statistical models symbolically, 2) on bridging the gap between symbolic mathe- matics and numerical computations and 3) on preparing teaching material in a reproducible framework (provided by, e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' rmarkdown [Allaire et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', 2021, Xie et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', 2018, 2020].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The caracas package is avail- able from CRAN [R Core Team, 2023].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The open-source development version of caracas is available at https://github.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='com/r-cas/caracas and readers are recommended to study the online documenta- tion at https://r-cas.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='github.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='io/caracas/.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The caracas package provides an interface from R to the Python package sympy [Meurer et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', 2017].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This means that SymPy is “running under the hood” of R via the reticulate package [Ushey et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', 2020].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The sympy package is mature and robust with many users and developers.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Neither caracas nor Ryacas are as powerful as some of the larger commercial computer algebra systems (CAS).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The virtue of caracas and Ryacas lie elsewhere: (1) Mathematical tools like equation solving, summation, limits, symbolic linear algebra, outputting in tex format etc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' are directly available from within R.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (2) The packages enable working with the same language and in the same environment as the user does for statistical analyses.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (3) Symbolic mathematics can easily be combined with data which is helpful in e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' numerical optimization.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (4) The packages are open-source and therefore support 1 arXiv:2301.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='13777v1 [stat.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='AP] 31 Jan 2023 e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' education - also for people with limited economical means and thus contributing to United Nations sustainable development goals [United Nations General Assembly, 2015].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The paper is organized in the following sections: The section Mathematics and documents containing mathematics briefly introduces the caracas package and its syntax, including how caracas can be used in connection with preparing texts, e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' teaching material.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' More details are provided in the Section Important technical aspects.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Several vignettes illustrating caracas are provided and they are also available online, see https://r-cas.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='github.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='io/caracas/.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The section Statistics examples is the main section of the paper and here we present a sample of statistical models where we believe that a symbolic treatment is a valuable supplement to a numerical in connection with teaching.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The section Possible topics to study contains suggestions about hand-on activities for students.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Lastly, the section Discussion and future work contains a discussion of the paper.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Mathematics and documents containing mathematics We start by introducing the caracas syntax on familiar topics within calculus and linear algebra.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Calculus First we define a caracas symbol x (more details will follow in Section Important technical aspects) and subsequently a caracas polynomial p in x (p becomes a symbol because x is): R> library(caracas) R> def_sym(x) ## Declares ’x’ as a symbol R> p <- 1 - x^2 + x^3 + x^4/4 - 3 * x^5 / 5 + x^6 / 6 R> p #> [c]: 6 5 4 #> x 3*x x 3 2 #> -- - ---- + -- + x x + 1 #> 6 5 4 The gradient of p is: R> grad <- der(p,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' x) ## ’der’ is shorthand for derivative R> grad #> [c]: 5 4 3 2 #> x 3*x + x + 3*x 2*x Stationary points of p can be found by finding roots of the gradient.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In this simple case we can factor the gradient: R> factor_(grad) #> [c]: 2 #> x*(x - 2)*(x - 1) *(x + 1) The factorizations shows that stationary points are −1, 0, 1 and 2.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' To investigate if extreme points are local minima,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' local maxima or saddle points,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' we compute the Hessian and evaluate the Hessian in the stationary points: R> hess <- der2(p,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' x) R> hess #> [c]: 4 3 2 #> 5*x 12*x + 3*x + 6*x - 2 R> hess_ <- as_func(hess) R> hess_ 2 #> function (x) #> { #> 5 * x^4 - 12 * x^3 + 3 * x^2 + 6 * x - 2 #> } #> R> stationary_points <- c(-1,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 0,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 1,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 2) R> hess_(stationary_points) #> [1] 12 -2 0 6 Alternatively,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' we can create an R expression and evaluate: R> eval(as_expr(hess),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' list(x = stationary_points)) #> [1] 12 -2 0 6 The sign of the Hessian in these points gives that x = −1 and x = 12 are local minima,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' x = 0 is a local maximum and x = 1 is a saddle point.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In general we can find the stationary symbolically and evaluate the Hessian as follows (output omitted): R> sol <- solve_sys(lhs = grad,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' vars = x) ## finds roots by default R> subs(hess,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' sol[[1]]) ## the first solution R> lapply(sol,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' function(s) subs(hess,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s)) ## iterate over all solutions Linear algebra Next,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' we create a symbolic matrix and find its inverse: R> M <- as_sym(toeplitz(c("a",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "b",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 0))) ## as_sym() converts an R object to caracas symbol R> Minv <- inv(M) %>% simplify() Default printing of M is (Minv is shown below in next section): R> M #> [c]: [a b 0] #> [ ] #> [b a b] #> [ ] #> [0 b a] A vector is a one-column matrix,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' but it is printed as its transpose to save space: R> v <- vector_sym(3,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "v") R> v #> [c]: [v1 v2 v3]^T Matrix products are computed using the %*% operator: R> M %*% v #> [c]: [a*v1 + b*v2 a*v2 + b*v1 + b*v3 a*v3 + b*v2]^T 3 Preparing mathematical documents The packages Sweave [Leisch,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 2002] and Rmarkdown [Allaire et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', 2021] provide integration of LaTeX and other text formatting systems into R helping to produce text document with R content.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In a similar vein, caracas provides an integration of computer algebra into R and in addition, caracas also facilitates creation of documents with mathematical content without e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' typing tedious LaTeX instructions.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' A LaTeX rendering of the caracas symbol p is obtained by typing $$p(x) = `r tex(p)`$$ which results in the following when the document is compiled: p(x) = x6 6 − 3x5 5 + x4 4 + x3 − x2 + 1 Typing $$Mˆ{-1} = `r tex(Minv)`$$ produces the result: M −1 = � �� a2−b2 a(a2−2b2) − b a2−2b2 b2 a(a2−2b2) − b a2−2b2 a a2−2b2 − b a2−2b2 b2 a(a2−2b2) − b a2−2b2 a2−b2 a(a2−2b2) � �� .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The determinant of M is det(M) = a3 −2∗a∗b2 and this can be factored out of the matrix by dividing each entry with the determinant and multiplying the new matrix by the determinant which simplifies the appearance of the matrix: R> Minv_fact <- as_factor_list(1 / factor_(det(M)), simplify(Minv * det(M))) Typing $$Mˆ{-1} = `r tex(Minv_fact)`$$ produces this: M −1 = 1 a (a2 − 2b2) � � a2 − b2 −ab b2 −ab a2 −ab b2 −ab a2 − b2 � � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Finally we illustrate creation of additional mathematical expressions: R> def_sym(x, n) R> y <- (1 + x/n)^n R> lim(y, n, Inf) #> [c]: exp(x) Typing $$y = `r tex(y)`$$ etc.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' gives y = � 1 + x n �n , lim n−>∞ y = exp(x).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' We can also prepare unevaluated expressions using the doit argument.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' That helps making repro- ducible documents where the changes in code appears automatically in the generated formulas.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This is done as follows: R> l <- lim(y, n, Inf, doit = FALSE) R> l #> [c]: n #> / x\\ #> lim |1 + -| #> n->oo\\ n/ R> doit(l) #> [c]: exp(x) Typing $$`r tex(l)` = `r tex(doit(l))`$$ gives lim n→∞ � 1 + x n �n = ex.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Several functions have the doit argument, e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' lim(), int() and sum_().' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 4 Important technical aspects A caracas symbol is a list with a pyobj slot and the class caracas_symbol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The pyobj is an an object in Python (often a sympy object).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' As such, a symbol (in R) provides a handle to a Python object.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In the design of caracas we have tried to make this distinction something the user should not be concerned with, but it is worthwhile being aware of the distinction.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Sections Calculus and Linear algebra illustrate that caracas symbols can be created with def_sym() and as_sym().' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Both declares the symbol in R and in Python.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' A symbol can also be defined in terms of other symbols: Define symbols s1 and s2 and define symbol s3 in terms of s1 and s2: R> def_sym(s1, s2) ## Note: ’s1’ and ’s2’ exist in both R and Python R> s1$pyobj #> s1 R> s3_ <- s1 * s2 ## Note: ’s3’ is a symbol in R;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' no corresponding object in Python R> s3_$pyobj #> s1*s2 The underscore in s3_ indicates that this expression is defined in terms of other symbols.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This convention is used through out the paper.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Next express s1 and s2 in terms of symbols u and v (which are created on the fly): R> s4_ <- subs(s3_, c("s1", "s2"), c("u+v", "u-v")) R> s4_ #> [c]: (u - v)*(u + v) Statistics examples In this section we examine larger statistical examples and demonstrate how caracas can help improve understanding of the models.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Linear models A matrix algebra approach to e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' linear models is very clear and concise.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' On the other hand, it can also be argued that matrix algebra obscures what is being computed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Numerical examples are useful for some aspects of the computations but not for other.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In this respect symbolic computations can be enlightening.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Consider a two-way analysis of variance (ANOVA) with one observation per group, see Table 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Table 1: Two-by-two layout of data.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' y11 y21 y12 y22 R> nr <- 2 R> nc <- 2 R> y <- matrix_sym(nr, nc, "y") R> dim(y) <- c(nr*nc, 1) R> y #> [c]: [y11 y21 y12 y22]^T R> dat <- expand.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='grid(r=factor(1:nr), s=factor(1:nc)) R> X <- model.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='matrix(~r+s, data=dat) |> as_sym() R> b <- vector_sym(ncol(X), "b") R> mu <- X %*% b 5 For the specific model we have random variables y = (yij).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' All yijs are assumed independent and yij ∼ N(µij, v).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The corresponding mean vector µ has the form given below: y = � ��� y11 y21 y12 y22 � ��� , X = � ��� 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 1 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 1 1 1 1 � ��� , b = � � b1 b2 b3 � � , µ = Xb = � ��� b1 b1 + b2 b1 + b3 b1 + b2 + b3 � ��� .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Above and elsewhere, dots represent zero.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The least squares estimate of b is the vector ˆb that minimizes ||y − Xb||2 which leads to the normal equations (X⊤X)b = X⊤y to be solved.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' If X has full rank, the unique solution to the normal equations is ˆb = (X⊤X)−1X⊤y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Hence the estimated mean vector is ˆµ = Xˆb = X(X⊤X)−1X⊤y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Symbolic computations are not needed for quantities involving only the model matrix X,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' but when it comes to computations involving y,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' a symbolic treatment of y is useful: R> XtX <- t(X) %*% X R> XtXinv <- inv(XtX) R> Xty <- t(X) %*% y R> b_hat <- XtXinv %*% Xty X⊤y = � � y11 + y12 + y21 + y22 y21 + y22 y12 + y22 � � ,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' ˆb = 1 4 � � 3y11 + y12 + y21 − y22 −2y11 − 2y12 + 2y21 + 2y22 −2y11 + 2y12 − 2y21 + 2y22 � � (1) Hence X⊤y (a sufficient reduction of data if the variance is known) consists of the sum of all observa- tions,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' the sum of observations in the second row and the sum of observations in the second column.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' For ˆb, the second component is, apart from a scaling, the sum of the second row minus the sum of the first row.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Likewise, the third component is the sum of the second column minus the sum of the first column.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' It is hard to give an interpretation of the first component of ˆb.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Logistic regression In the following we go through details of a logistic regression model, see e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' McCullagh and Nelder [1989] for a classical description of logistic regression: Observables are binomially distributed, yi ∼ bin(pi, ni).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The probability pi is connected to a q-vector of covariates xi = (xi1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , xiq) and a q-vector of regression coefficients b = (b1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , bq) as follows: The term si = xi ·b is denoted the linear predictor.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The probability pi can be linked to si in different ways, but the most commonly employed is via the logit link function which is logit(pi) = log(pi/(1 − pi)) so here logit(pi) = si.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' As an example, consider the budworm data from the doBy package [Højsgaard and Halekoh, 2023].' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The data shows the number of killed moth tobacco budworm Heliothis virescens.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Batches of 20 moths of each sex were exposed for three days to the pyrethroid and the number in each batch that were dead or knocked down was recorded: R> data(budworm,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' package = "doBy") R> bud <- subset(budworm,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' sex == "male") R> bud #> sex dose ndead ntotal #> 1 male 1 1 20 #> 2 male 2 4 20 #> 3 male 4 9 20 #> 4 male 8 13 20 #> 5 male 16 18 20 #> 6 male 32 20 20 Below we focus only on male budworms and the mortality is illustrated in Figure 1 (produced with ggplot2 [Wickham,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 2016]).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' On the y-axis we have the empirical logits, i.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' log((ndead + 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='5)/(ntotal − ndead + 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='5)).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The figure suggests that logit grows linearly with log dose.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 6 −2 0 2 4 0 10 20 30 dose Empirical logits −2 0 2 4 0 1 2 3 4 5 log2(dose) Empirical logits Figure 1: Insecticide mortality of the moth tobacco budworm.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Each component of the likelihood The log-likelihood is log L = � i yi log(pi)+(ni−yi) log(1−pi) = � i log Li, say.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' With log(pi/(1−pi)) = si we have pi = 1/(1 + exp(−si)) and d dsi pi = exp(−si) (1+exp(−si))2 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' With si = xi · b, we have d dbsi = xi.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Consider the contribution to the total log-likelihood from the ith observation which is li = yi log(pi)+ (ni − yi) log(1 − pi).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Since we are focusing on one observation only, we shall ignore the subscript i in this section.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' First notice that with s = log(p/(1 − p)) we can find p as: R> def_sym(s, p) R> sol_ <- solve_sys(lhs = log(p / (1 - p)), rhs = s, vars = p) R> sol_[[1]]$p #> [c]: exp(s) #> ---------- #> exp(s) + 1 Next, find the likelihood as a function of p, as a function of s and as a function of b.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The underscore in logLb_ and elsewhere indicates that this expression is defined in terms of other symbols (this is in contrast to the free variables, e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' y, p, and n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='): R> def_sym(y, n, p, x, s, b) R> logLp_ <- y * log(p) + (n - y) * log(1 - p) R> p_ <- exp(s) / (exp(s) + 1) R> logLs_ <- subs(logLp_, p, p_) R> s_ <- sum(x * b) R> logLb_ <- subs(logLs_, s, s_) R> logLb_ #> [c]: / exp(b*x) \\ / exp(b*x) \\ #> y*log|------------| + (n - y)*log|1 - ------------| #> \\exp(b*x) + 1/ \\ exp(b*x) + 1/ The log-likelihood can be maximized using e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Newton-Rapson (see e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Nocedal and Wright [2006]) and in this connection we need the score function,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' S,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' and the Hessian,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' H: R> Sb_ <- score(logLb_,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' b) |> simplify() R> Hb_ <- hessian(logLb_,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' b) |> simplify() R> Sb_ #> [c]: [x*(y - (n - y)*exp(b*x))] #> [------------------------] #> [ exp(b*x) + 1 ] R> Hb_ 7 #> [c]: [ 2 ] #> [ n*x *exp(b*x) ] #> [---------------------------] #> [exp(2*b*x) + 2*exp(b*x) + 1] Since x and b are vectors,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' the term b*x above should be read as the inner product x · b (or as x⊤b in matrix notation).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Also, since x is a vector, the term xˆ2 above should be read as the outer product x ⊗ x (or as xx⊤ in matrix notation).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' More insight in the structure is obtained by letting b and x be 2-vectors (to save space,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' the Hessian matrix is omitted in the following): R> b <- vector_sym(2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "b") R> x <- vector_sym(2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "x") R> s_ <- sum(x * b) R> logLb_ <- subs(logLs_,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s_) R> Sb_ <- score(logLb_,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' b) |> simplify() logLb_ = y log � eb1x1+b2x2 eb1x1+b2x2 + 1 � + (n − y) log � 1 − eb1x1+b2x2 eb1x1+b2x2 + 1 � ,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (2) Sb_ = � � x1(−neb1x1+b2x2+yeb1x1+b2x2+y) eb1x1+b2x2+1 x2(−neb1x1+b2x2+yeb1x1+b2x2+y) eb1x1+b2x2+1 � � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (3) Next, insert data, e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' x1 = 1, x2 = 2, y = 9, n = 20 to obtain a function of the regression parameters only.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Note how the expression depending on other symbols, S_, is named S.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' to indicate that data has been inserted: R> nms <- c("x1", "x2", "y", "n") R> vls <- c(1, 2, 9, 20) R> logLb.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- subs(logLb_, nms, vls) R> Sb.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- subs(Sb_, nms, vls) The total score for the entire dataset can be obtained as follows: R> Sb_list <- lapply(seq_len(nrow(bud)), function(r){ + vls <- c(1, log2(bud$dose[r]), bud$ndead[r], bud$ntotal[r]) + subs(Sb_, nms, vls) + }) R> Sb_total <- Reduce(‘+‘, Sb_list) This score can be used as part of an iterative algorithm for solving the score equations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' If one wants to use Newton-Rapson, the total Hessian matrix must also be created following lines similar to those above.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' It is straight forward implement a Newton-Rapson algorithm based on these quantities,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' one must only note the distinction between the two expressions below (and it is the latter one would use in an iterative algorithm): R> subs(Sb_total,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' b,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' c(1,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 2)) R> subs(Sb_total,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' b,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' c(1,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 2)) |> as_expr() An alternative is to construct the total log-likelihood for the entire dataset as a caracas object,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' convert this object to an R function and maximize this function using one of R’s optimization methods: R> logLb_list <- lapply(seq_len(nrow(bud)),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' function(r){ + vls <- c(1,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' log2(bud$dose[r]),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' bud$ndead[r],' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' bud$ntotal[r]) + subs(logLb_,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' nms,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' vls) + }) R> logLb_total <- Reduce(‘+‘,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' logLb_list) R> logLb_total_func <- as_func(logLb_total,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' vec_arg = TRUE) 8 The total likelihood symbolically We conclude this section by illustrating that the log-likelihood for the entire dataset can be constructed in a few steps (output is omitted to save space): R> X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- as_sym(cbind(1, log2(bud$dose))) R> n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- as_sym(bud$ntotal) R> y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- as_sym(bud$ndead) R> N <- nrow(X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=') R> q <- ncol(X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=') R> X <- matrix_sym(N, q, "x") R> n <- vector_sym(N, "n") R> y <- vector_sym(N, "y") R> p <- vector_sym(N, "p") R> s <- vector_sym(N, "s") R> b <- vector_sym(q, "b") X = � ������� x11 x12 x21 x22 x31 x32 x41 x42 x51 x52 x61 x62 � ������� , X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' = � ������� 1 0 1 1 1 2 1 3 1 4 1 5 � ������� , n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' = � ������� 20 20 20 20 20 20 � ������� , n = � ������� n1 n2 n3 n4 n5 n6 � ������� , y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' = � ������� 1 4 9 13 18 20 � ������� .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The symbolic computations are as follows: R> ## log-likelihood as function of p R> logLp <- sum(y * log(p) + (n-y) * log(1-p)) R> ## log-likelihood as function of s R> p_ <- exp(s) / (exp(s) + 1) R> logLs <- subs(logLp,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' p,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' p_) R> ## linear predictor as function of regression coefficients: R> s_ <- X %*% b R> ## log-Likelihood as function of regression coefficients: R> logLb <- subs(logLs,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s_) Next,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' numerical values can be inserted: R> logLb <- subs(logLb,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' cbind(n,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' y,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' X),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' cbind(n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=')) An alternative would have been to define logLp above in terms of n.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' and y.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' and similarly define s_ in terms of X.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' If doing so, the last step where numerical values are inserted could have been avoided.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' From here, one may proceed by computing the score function and the Hessian matrix and solve the score equation, using e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Newton-Rapson.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Alternatively, one might create an R function based on the log-likelihood, and maximize this function using one of R’s optimization methods (see the example in the previous section): R> logLb_func <- as_func(logLb, vec_arg = TRUE) R> optim(c(0, 0), logLb_func, control = list(fnscale = -1), hessian = TRUE) Maximum likelihood under constraints In this section we illustrate constrained optimization using Lagrange multipliers.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This is demonstrated for the independence model for a two-way contingency table.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Consider a 2 × 2 contingency table with cell counts yij and cell probabilities pij for i = 1, 2 and j = 1, 2, where i refers to row and j to column as illustrated in Table 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Under multinomial sampling, the log likelihood is l = log L = � ij yij log(pij).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 9 Under the assumption of independence between rows and columns, the cell probabilities have the form, (see e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Højsgaard et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' [2012], p.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 32) pij = u · ri · sj.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' To make the parameters (u, ri, sj) identifiable, constraints must be imposed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' One possibility is to require that r1 = s1 = 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The task is then to estimate u, r2, s2 by maximizing the log likelihood under the constraint that � ij pij = 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' This can be achieved using a Lagrange multiplier where we instead solve the unconstrained optimization problem maxp Lag(p) where Lag(p) = −l(p) + λg(p) under the constraint that (4) g(p) = � ij pij − 1 = 0, (5) where λ is a Lagrange multiplier.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' In SymPy, lambda is a reserved symbol.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Hence the underscore as postfix below: R> y_ <- c("y_11",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "y_21",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "y_12",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "y_22") R> y <- as_sym(y_) R> def_sym(u,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' r2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' lambda_) R> p <- as_sym(c("u",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "u*r2",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "u*s2",' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' "u*r2*s2")) R> logL <- sum(y * log(p)) R> Lag <- -logL + lambda_ * (sum(p) - 1) R> vars <- list(u,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' r2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' lambda_) R> gLag <- der(Lag,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' vars) R> sol <- solve_sys(gLag,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' vars) R> print(sol,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' method = "ascii") #> Solution 1: #> lambda_ = y_11 + y_12 + y_21 + y_22 #> r2 = (y_21 + y_22)/(y_11 + y_12) #> s2 = (y_12 + y_22)/(y_11 + y_21) #> u = (y_11 + y_12)*(y_11 + y_21)/(y_11 + y_12 + y_21 + y_22)^2 R> sol <- sol[[1]] There is only one critical point.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Fitted cell probabilities ˆpij are: R> p11 <- sol$u R> p21 <- sol$u * sol$r2 R> p12 <- sol$u * sol$s2 R> p22 <- sol$u * sol$r2 * sol$s2 R> p.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='hat <- matrix_(c(p11,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' p21,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' p12,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' p22),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' nrow = 2) ˆp = 1 (y11 + y12 + y21 + y22)2 � (y11 + y12) (y11 + y21) (y11 + y12) (y12 + y22) (y11 + y21) (y21 + y22) (y12 + y22) (y21 + y22) � To verify that the maximum likelihood estimate has been found,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' we compute the Hessian matrix which is negative definite (the Hessian matrix is diagonal so the eigenvalues are the diagonal entries and these are all negative),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' output omitted: R> H <- hessian(logL,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' list(u,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' r2,' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' s2)) |> simplify() An AR(1) model Symbolic computations In this section we study the auto regressive model of order 1 (an AR(1) model),' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' see e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Shumway and Stoffer [2016], p.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 75 ff.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' for details: Consider random variables x1, x2, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , xn following a stationary zero mean AR(1) process: xi = axi−1 + ei;' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' i = 2, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , n, (6) 10 where ei ∼ N(0, v) and all eis are independent.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Note that v denotes the variance.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The marginal distribution of x1 is also assumed normal, and for the process to be stationary we must have that the variance Var(x1) = v/(1 − a2).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Hence we can write x1 = 1 √ 1−a2 e1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' For simplicity of exposition, we set n = 4.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' All terms e1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , e4 are independent and N(0, v) distributed.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Let e = (e1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , e4) and x = (x1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' x4).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Hence e ∼ N(0, vI).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Isolating error terms in (6) gives e = � ��� e1 e2 e3 e4 � ��� = � ��� √ 1 − a2 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a 1 � ��� � ��� x1 x2 x3 x4 � ��� = Lx.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Since Var(e) = vI we have Var(e) = vI = LVar(x)L′ so the covariance matrix of x is V = Var(x) = vL−(L−)⊤ while the concentration matrix (the inverse covariance matrix) is K = v−1L⊤L: R> n <- 4 R> L <- diff_mat(n, "-a") R> def_sym(a) R> L[1, 1] <- sqrt(1-a^2) R> def_sym(v) R> Linv <- inv(L) R> K <- crossprod_(L) / v R> V <- tcrossprod_(Linv) * v L−1 = � ���� 1 √ 1−a2 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' a √ 1−a2 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' a2 √ 1−a2 a 1 .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' a3 √ 1−a2 a2 a 1 � ���� , (7) K = 1 v � ��� 1 −a .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a a2 + 1 −a .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a a2 + 1 −a .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' −a 1 � ��� , (8) V = v � ���� 1 1−a2 a 1−a2 a2 1−a2 a3 1−a2 a 1−a2 a2 1−a2 + 1 a3 1−a2 + a a4 1−a2 + a2 a2 1−a2 a3 1−a2 + a a4 1−a2 + a2 + 1 a5 1−a2 + a3 + a a3 1−a2 a4 1−a2 + a2 a5 1−a2 + a3 + a a6 1−a2 + a4 + a2 + 1 � ���� .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (9) The zeros in the concentration matrix K implies a conditional independence restriction: If the ijth element of a concentration matrix is zero then xi and xj are conditionally independent given all other variables, see e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Højsgaard et al.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' [2012], p.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 84 for details.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Next, we take the step from symbolic computations to numerical evaluations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The joint distribution of x is multivariate normal distribution, x ∼ N(0, K−1).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Let W = xx⊤ denote the matrix of (cross) products.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The log-likelihood is therefore (ignoring additive constants) log L = n 2 (log det(K) − x⊤Kx) = n 2 (log det(K) − tr(KW)), where we note that tr(KW) is the sum of the elementwise products of K and W since both matrices are symmetric.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Ignoring the constant n 2 , this can be written symbolically to obtain the expression in this particular case: R> x <- vector_sym(n, "x") R> logL <- log(det(K)) - sum(K * (x %*% t(x))) %>% simplify() log L = log � −a2 v4 + 1 v4 � − −2ax1x2 − 2ax2x3 − 2ax3x4 + x2 1 + x2 2 � a2 + 1 � + x2 3 � a2 + 1 � + x2 4 v .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' 11 Numerical evaluation Next we illustrate how bridge the gap from symbolic computations to numerical computations based on a dataset: For a specific data vector we get: R> xt <- c(0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='1, -0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='9, 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='4, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='0) R> logL.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' <- subs(logL, x, xt) log L = log � −a2 v4 + 1 v4 � − 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='97a2 + 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='9a + 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='98 v .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' We can use R for numerical maximization of the likelihood and constraints on the parameter values can be imposed e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' in the optim() function: R> logL_wrap <- as_func(logL.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=', vec_arg = TRUE) R> eps <- 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='01 R> par <- optim(c(a=0, v=1), logL_wrap, + lower=c(-(1-eps), eps), upper=c((1-eps), 10), + method="L-BFGS-B", control=list(fnscale=-1))$par R> par #> a v #> -0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='376 0.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='195 The same model can be fitted e.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='g.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' using R’s arima() function as follows (output omitted): R> arima(xt, order = c(1, 0, 0), include.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content='mean = FALSE, method = "ML") It is less trivial to do the optimization in caracas by solving the score equations.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' There are some possibilities for putting assumptions on variables in caracas (see the “Reference” vignette), but it is not possible to restrict the parameter a to only take values in (−1, 1).' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Variance of the average of correlated data Consider random variables x1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , xn where Var(xi) = v and Cov(xi, xj) = vr for i ̸= j, where 0 ≤ |r| ≤ 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' For n = 3, the covariance matrix of (x1, .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' , xn) is therefore V = vR = v � � 1 r r r 1 r r r 1 � � .' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' (10) Let ¯x = � i xi/n denote the average.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Suppose interest is in the variance of the average, Var(¯x), when n goes to infinity.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' One approach is as follow: Let 1 denote an n-vector of 1’s and let V be an n × n matrix with v on the diagonal and vr outside the diagonal.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' Then Var(¯x) = 1 n2 1⊤V 1.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' The answer lies in studying the limiting behaviour of this expression when n → ∞.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' First, we must calculate variance of a sum x.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=' = � i xi which is Var(x.' metadata={'source': '/home/zjlab/wf/langchain-ChatGLM/knowledge_base/0dFST4oBgHgl3EQfVTiq/content/2301.13777v1.pdf'} +page_content=') = � i Var(xi) + 2 � ij:i